Home | History | Annotate | Line # | Download | only in opcodes
aarch64-dis-2.c revision 1.1.1.7
      1 /* This file is automatically generated by aarch64-gen.  Do not edit!  */
      2 /* Copyright (C) 2012-2020 Free Software Foundation, Inc.
      3    Contributed by ARM Ltd.
      4 
      5    This file is part of the GNU opcodes library.
      6 
      7    This library is free software; you can redistribute it and/or modify
      8    it under the terms of the GNU General Public License as published by
      9    the Free Software Foundation; either version 3, or (at your option)
     10    any later version.
     11 
     12    It is distributed in the hope that it will be useful, but WITHOUT
     13    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
     14    or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public
     15    License for more details.
     16 
     17    You should have received a copy of the GNU General Public License
     18    along with this program; see the file COPYING3. If not,
     19    see <http://www.gnu.org/licenses/>.  */
     20 
     21 #include "sysdep.h"
     22 #include "aarch64-dis.h"
     23 
     24 /* Called by aarch64_opcode_lookup.  */
     25 
     26 static int
     27 aarch64_opcode_lookup_1 (uint32_t word)
     28 {
     29   if (((word >> 26) & 0x1) == 0)
     30     {
     31       if (((word >> 25) & 0x1) == 0)
     32         {
     33           if (((word >> 27) & 0x1) == 0)
     34             {
     35               if (((word >> 24) & 0x1) == 0)
     36                 {
     37                   if (((word >> 28) & 0x1) == 0)
     38                     {
     39                       /* 33222222222211111111110000000000
     40                          10987654321098765432109876543210
     41                          xxx00000xxxxxxxxxxxxxxxxxxxxxxxx
     42                          udf.  */
     43                       return 754;
     44                     }
     45                   else
     46                     {
     47                       if (((word >> 31) & 0x1) == 0)
     48                         {
     49                           /* 33222222222211111111110000000000
     50                              10987654321098765432109876543210
     51                              0xx10000xxxxxxxxxxxxxxxxxxxxxxxx
     52                              adr.  */
     53                           return 1187;
     54                         }
     55                       else
     56                         {
     57                           /* 33222222222211111111110000000000
     58                              10987654321098765432109876543210
     59                              1xx10000xxxxxxxxxxxxxxxxxxxxxxxx
     60                              adrp.  */
     61                           return 1188;
     62                         }
     63                     }
     64                 }
     65               else
     66                 {
     67                   if (((word >> 29) & 0x1) == 0)
     68                     {
     69                       if (((word >> 30) & 0x1) == 0)
     70                         {
     71                           /* 33222222222211111111110000000000
     72                              10987654321098765432109876543210
     73                              x00x0001xxxxxxxxxxxxxxxxxxxxxxxx
     74                              add.  */
     75                           return 12;
     76                         }
     77                       else
     78                         {
     79                           /* 33222222222211111111110000000000
     80                              10987654321098765432109876543210
     81                              x10x0001xxxxxxxxxxxxxxxxxxxxxxxx
     82                              sub.  */
     83                           return 16;
     84                         }
     85                     }
     86                   else
     87                     {
     88                       if (((word >> 30) & 0x1) == 0)
     89                         {
     90                           /* 33222222222211111111110000000000
     91                              10987654321098765432109876543210
     92                              x01x0001xxxxxxxxxxxxxxxxxxxxxxxx
     93                              adds.  */
     94                           return 14;
     95                         }
     96                       else
     97                         {
     98                           /* 33222222222211111111110000000000
     99                              10987654321098765432109876543210
    100                              x11x0001xxxxxxxxxxxxxxxxxxxxxxxx
    101                              subs.  */
    102                           return 17;
    103                         }
    104                     }
    105                 }
    106             }
    107           else
    108             {
    109               if (((word >> 28) & 0x1) == 0)
    110                 {
    111                   if (((word >> 22) & 0x1) == 0)
    112                     {
    113                       if (((word >> 23) & 0x1) == 0)
    114                         {
    115                           if (((word >> 29) & 0x1) == 0)
    116                             {
    117                               if (((word >> 15) & 0x1) == 0)
    118                                 {
    119                                   if (((word >> 21) & 0x1) == 0)
    120                                     {
    121                                       if (((word >> 31) & 0x1) == 0)
    122                                         {
    123                                           if (((word >> 30) & 0x1) == 0)
    124                                             {
    125                                               /* 33222222222211111111110000000000
    126                                                  10987654321098765432109876543210
    127                                                  0000100x000xxxxx0xxxxxxxxxxxxxxx
    128                                                  stxrb.  */
    129                                               return 937;
    130                                             }
    131                                           else
    132                                             {
    133                                               /* 33222222222211111111110000000000
    134                                                  10987654321098765432109876543210
    135                                                  0100100x000xxxxx0xxxxxxxxxxxxxxx
    136                                                  stxrh.  */
    137                                               return 943;
    138                                             }
    139                                         }
    140                                       else
    141                                         {
    142                                           /* 33222222222211111111110000000000
    143                                              10987654321098765432109876543210
    144                                              1x00100x000xxxxx0xxxxxxxxxxxxxxx
    145                                              stxr.  */
    146                                           return 949;
    147                                         }
    148                                     }
    149                                   else
    150                                     {
    151                                       if (((word >> 31) & 0x1) == 0)
    152                                         {
    153                                           /* 33222222222211111111110000000000
    154                                              10987654321098765432109876543210
    155                                              0x00100x001xxxxx0xxxxxxxxxxxxxxx
    156                                              casp.  */
    157                                           return 1022;
    158                                         }
    159                                       else
    160                                         {
    161                                           /* 33222222222211111111110000000000
    162                                              10987654321098765432109876543210
    163                                              1x00100x001xxxxx0xxxxxxxxxxxxxxx
    164                                              stxp.  */
    165                                           return 951;
    166                                         }
    167                                     }
    168                                 }
    169                               else
    170                                 {
    171                                   if (((word >> 21) & 0x1) == 0)
    172                                     {
    173                                       if (((word >> 31) & 0x1) == 0)
    174                                         {
    175                                           if (((word >> 30) & 0x1) == 0)
    176                                             {
    177                                               /* 33222222222211111111110000000000
    178                                                  10987654321098765432109876543210
    179                                                  0000100x000xxxxx1xxxxxxxxxxxxxxx
    180                                                  stlxrb.  */
    181                                               return 938;
    182                                             }
    183                                           else
    184                                             {
    185                                               /* 33222222222211111111110000000000
    186                                                  10987654321098765432109876543210
    187                                                  0100100x000xxxxx1xxxxxxxxxxxxxxx
    188                                                  stlxrh.  */
    189                                               return 944;
    190                                             }
    191                                         }
    192                                       else
    193                                         {
    194                                           /* 33222222222211111111110000000000
    195                                              10987654321098765432109876543210
    196                                              1x00100x000xxxxx1xxxxxxxxxxxxxxx
    197                                              stlxr.  */
    198                                           return 950;
    199                                         }
    200                                     }
    201                                   else
    202                                     {
    203                                       if (((word >> 31) & 0x1) == 0)
    204                                         {
    205                                           /* 33222222222211111111110000000000
    206                                              10987654321098765432109876543210
    207                                              0x00100x001xxxxx1xxxxxxxxxxxxxxx
    208                                              caspl.  */
    209                                           return 1024;
    210                                         }
    211                                       else
    212                                         {
    213                                           /* 33222222222211111111110000000000
    214                                              10987654321098765432109876543210
    215                                              1x00100x001xxxxx1xxxxxxxxxxxxxxx
    216                                              stlxp.  */
    217                                           return 952;
    218                                         }
    219                                     }
    220                                 }
    221                             }
    222                           else
    223                             {
    224                               if (((word >> 30) & 0x1) == 0)
    225                                 {
    226                                   /* 33222222222211111111110000000000
    227                                      10987654321098765432109876543210
    228                                      x010100x00xxxxxxxxxxxxxxxxxxxxxx
    229                                      stnp.  */
    230                                   return 971;
    231                                 }
    232                               else
    233                                 {
    234                                   /* 33222222222211111111110000000000
    235                                      10987654321098765432109876543210
    236                                      x110100x00xxxxxxxxxxxxxxxxxxxxxx
    237                                      stgp.  */
    238                                   return 980;
    239                                 }
    240                             }
    241                         }
    242                       else
    243                         {
    244                           if (((word >> 29) & 0x1) == 0)
    245                             {
    246                               if (((word >> 15) & 0x1) == 0)
    247                                 {
    248                                   if (((word >> 21) & 0x1) == 0)
    249                                     {
    250                                       if (((word >> 31) & 0x1) == 0)
    251                                         {
    252                                           /* 33222222222211111111110000000000
    253                                              10987654321098765432109876543210
    254                                              0x00100x100xxxxx0xxxxxxxxxxxxxxx
    255                                              stllrb.  */
    256                                           return 969;
    257                                         }
    258                                       else
    259                                         {
    260                                           /* 33222222222211111111110000000000
    261                                              10987654321098765432109876543210
    262                                              1x00100x100xxxxx0xxxxxxxxxxxxxxx
    263                                              stllr.  */
    264                                           return 968;
    265                                         }
    266                                     }
    267                                   else
    268                                     {
    269                                       if (((word >> 31) & 0x1) == 0)
    270                                         {
    271                                           if (((word >> 30) & 0x1) == 0)
    272                                             {
    273                                               /* 33222222222211111111110000000000
    274                                                  10987654321098765432109876543210
    275                                                  0000100x101xxxxx0xxxxxxxxxxxxxxx
    276                                                  casb.  */
    277                                               return 1010;
    278                                             }
    279                                           else
    280                                             {
    281                                               /* 33222222222211111111110000000000
    282                                                  10987654321098765432109876543210
    283                                                  0100100x101xxxxx0xxxxxxxxxxxxxxx
    284                                                  cash.  */
    285                                               return 1011;
    286                                             }
    287                                         }
    288                                       else
    289                                         {
    290                                           /* 33222222222211111111110000000000
    291                                              10987654321098765432109876543210
    292                                              1x00100x101xxxxx0xxxxxxxxxxxxxxx
    293                                              cas.  */
    294                                           return 1012;
    295                                         }
    296                                     }
    297                                 }
    298                               else
    299                                 {
    300                                   if (((word >> 21) & 0x1) == 0)
    301                                     {
    302                                       if (((word >> 31) & 0x1) == 0)
    303                                         {
    304                                           if (((word >> 30) & 0x1) == 0)
    305                                             {
    306                                               /* 33222222222211111111110000000000
    307                                                  10987654321098765432109876543210
    308                                                  0000100x100xxxxx1xxxxxxxxxxxxxxx
    309                                                  stlrb.  */
    310                                               return 941;
    311                                             }
    312                                           else
    313                                             {
    314                                               /* 33222222222211111111110000000000
    315                                                  10987654321098765432109876543210
    316                                                  0100100x100xxxxx1xxxxxxxxxxxxxxx
    317                                                  stlrh.  */
    318                                               return 947;
    319                                             }
    320                                         }
    321                                       else
    322                                         {
    323                                           /* 33222222222211111111110000000000
    324                                              10987654321098765432109876543210
    325                                              1x00100x100xxxxx1xxxxxxxxxxxxxxx
    326                                              stlr.  */
    327                                           return 957;
    328                                         }
    329                                     }
    330                                   else
    331                                     {
    332                                       if (((word >> 31) & 0x1) == 0)
    333                                         {
    334                                           if (((word >> 30) & 0x1) == 0)
    335                                             {
    336                                               /* 33222222222211111111110000000000
    337                                                  10987654321098765432109876543210
    338                                                  0000100x101xxxxx1xxxxxxxxxxxxxxx
    339                                                  caslb.  */
    340                                               return 1014;
    341                                             }
    342                                           else
    343                                             {
    344                                               /* 33222222222211111111110000000000
    345                                                  10987654321098765432109876543210
    346                                                  0100100x101xxxxx1xxxxxxxxxxxxxxx
    347                                                  caslh.  */
    348                                               return 1017;
    349                                             }
    350                                         }
    351                                       else
    352                                         {
    353                                           /* 33222222222211111111110000000000
    354                                              10987654321098765432109876543210
    355                                              1x00100x101xxxxx1xxxxxxxxxxxxxxx
    356                                              casl.  */
    357                                           return 1020;
    358                                         }
    359                                     }
    360                                 }
    361                             }
    362                           else
    363                             {
    364                               if (((word >> 30) & 0x1) == 0)
    365                                 {
    366                                   /* 33222222222211111111110000000000
    367                                      10987654321098765432109876543210
    368                                      x010100x10xxxxxxxxxxxxxxxxxxxxxx
    369                                      stp.  */
    370                                   return 981;
    371                                 }
    372                               else
    373                                 {
    374                                   /* 33222222222211111111110000000000
    375                                      10987654321098765432109876543210
    376                                      x110100x10xxxxxxxxxxxxxxxxxxxxxx
    377                                      stgp.  */
    378                                   return 986;
    379                                 }
    380                             }
    381                         }
    382                     }
    383                   else
    384                     {
    385                       if (((word >> 23) & 0x1) == 0)
    386                         {
    387                           if (((word >> 29) & 0x1) == 0)
    388                             {
    389                               if (((word >> 15) & 0x1) == 0)
    390                                 {
    391                                   if (((word >> 21) & 0x1) == 0)
    392                                     {
    393                                       if (((word >> 31) & 0x1) == 0)
    394                                         {
    395                                           if (((word >> 30) & 0x1) == 0)
    396                                             {
    397                                               /* 33222222222211111111110000000000
    398                                                  10987654321098765432109876543210
    399                                                  0000100x010xxxxx0xxxxxxxxxxxxxxx
    400                                                  ldxrb.  */
    401                                               return 939;
    402                                             }
    403                                           else
    404                                             {
    405                                               /* 33222222222211111111110000000000
    406                                                  10987654321098765432109876543210
    407                                                  0100100x010xxxxx0xxxxxxxxxxxxxxx
    408                                                  ldxrh.  */
    409                                               return 945;
    410                                             }
    411                                         }
    412                                       else
    413                                         {
    414                                           /* 33222222222211111111110000000000
    415                                              10987654321098765432109876543210
    416                                              1x00100x010xxxxx0xxxxxxxxxxxxxxx
    417                                              ldxr.  */
    418                                           return 953;
    419                                         }
    420                                     }
    421                                   else
    422                                     {
    423                                       if (((word >> 31) & 0x1) == 0)
    424                                         {
    425                                           /* 33222222222211111111110000000000
    426                                              10987654321098765432109876543210
    427                                              0x00100x011xxxxx0xxxxxxxxxxxxxxx
    428                                              caspa.  */
    429                                           return 1023;
    430                                         }
    431                                       else
    432                                         {
    433                                           /* 33222222222211111111110000000000
    434                                              10987654321098765432109876543210
    435                                              1x00100x011xxxxx0xxxxxxxxxxxxxxx
    436                                              ldxp.  */
    437                                           return 955;
    438                                         }
    439                                     }
    440                                 }
    441                               else
    442                                 {
    443                                   if (((word >> 21) & 0x1) == 0)
    444                                     {
    445                                       if (((word >> 31) & 0x1) == 0)
    446                                         {
    447                                           if (((word >> 30) & 0x1) == 0)
    448                                             {
    449                                               /* 33222222222211111111110000000000
    450                                                  10987654321098765432109876543210
    451                                                  0000100x010xxxxx1xxxxxxxxxxxxxxx
    452                                                  ldaxrb.  */
    453                                               return 940;
    454                                             }
    455                                           else
    456                                             {
    457                                               /* 33222222222211111111110000000000
    458                                                  10987654321098765432109876543210
    459                                                  0100100x010xxxxx1xxxxxxxxxxxxxxx
    460                                                  ldaxrh.  */
    461                                               return 946;
    462                                             }
    463                                         }
    464                                       else
    465                                         {
    466                                           /* 33222222222211111111110000000000
    467                                              10987654321098765432109876543210
    468                                              1x00100x010xxxxx1xxxxxxxxxxxxxxx
    469                                              ldaxr.  */
    470                                           return 954;
    471                                         }
    472                                     }
    473                                   else
    474                                     {
    475                                       if (((word >> 31) & 0x1) == 0)
    476                                         {
    477                                           /* 33222222222211111111110000000000
    478                                              10987654321098765432109876543210
    479                                              0x00100x011xxxxx1xxxxxxxxxxxxxxx
    480                                              caspal.  */
    481                                           return 1025;
    482                                         }
    483                                       else
    484                                         {
    485                                           /* 33222222222211111111110000000000
    486                                              10987654321098765432109876543210
    487                                              1x00100x011xxxxx1xxxxxxxxxxxxxxx
    488                                              ldaxp.  */
    489                                           return 956;
    490                                         }
    491                                     }
    492                                 }
    493                             }
    494                           else
    495                             {
    496                               if (((word >> 30) & 0x1) == 0)
    497                                 {
    498                                   /* 33222222222211111111110000000000
    499                                      10987654321098765432109876543210
    500                                      x010100x01xxxxxxxxxxxxxxxxxxxxxx
    501                                      ldnp.  */
    502                                   return 972;
    503                                 }
    504                               else
    505                                 {
    506                                   /* 33222222222211111111110000000000
    507                                      10987654321098765432109876543210
    508                                      x110100x01xxxxxxxxxxxxxxxxxxxxxx
    509                                      ldpsw.  */
    510                                   return 979;
    511                                 }
    512                             }
    513                         }
    514                       else
    515                         {
    516                           if (((word >> 29) & 0x1) == 0)
    517                             {
    518                               if (((word >> 15) & 0x1) == 0)
    519                                 {
    520                                   if (((word >> 21) & 0x1) == 0)
    521                                     {
    522                                       if (((word >> 31) & 0x1) == 0)
    523                                         {
    524                                           if (((word >> 30) & 0x1) == 0)
    525                                             {
    526                                               /* 33222222222211111111110000000000
    527                                                  10987654321098765432109876543210
    528                                                  0000100x110xxxxx0xxxxxxxxxxxxxxx
    529                                                  ldlarb.  */
    530                                               return 966;
    531                                             }
    532                                           else
    533                                             {
    534                                               /* 33222222222211111111110000000000
    535                                                  10987654321098765432109876543210
    536                                                  0100100x110xxxxx0xxxxxxxxxxxxxxx
    537                                                  ldlarh.  */
    538                                               return 967;
    539                                             }
    540                                         }
    541                                       else
    542                                         {
    543                                           /* 33222222222211111111110000000000
    544                                              10987654321098765432109876543210
    545                                              1x00100x110xxxxx0xxxxxxxxxxxxxxx
    546                                              ldlar.  */
    547                                           return 965;
    548                                         }
    549                                     }
    550                                   else
    551                                     {
    552                                       if (((word >> 31) & 0x1) == 0)
    553                                         {
    554                                           if (((word >> 30) & 0x1) == 0)
    555                                             {
    556                                               /* 33222222222211111111110000000000
    557                                                  10987654321098765432109876543210
    558                                                  0000100x111xxxxx0xxxxxxxxxxxxxxx
    559                                                  casab.  */
    560                                               return 1013;
    561                                             }
    562                                           else
    563                                             {
    564                                               /* 33222222222211111111110000000000
    565                                                  10987654321098765432109876543210
    566                                                  0100100x111xxxxx0xxxxxxxxxxxxxxx
    567                                                  casah.  */
    568                                               return 1016;
    569                                             }
    570                                         }
    571                                       else
    572                                         {
    573                                           /* 33222222222211111111110000000000
    574                                              10987654321098765432109876543210
    575                                              1x00100x111xxxxx0xxxxxxxxxxxxxxx
    576                                              casa.  */
    577                                           return 1019;
    578                                         }
    579                                     }
    580                                 }
    581                               else
    582                                 {
    583                                   if (((word >> 21) & 0x1) == 0)
    584                                     {
    585                                       if (((word >> 31) & 0x1) == 0)
    586                                         {
    587                                           if (((word >> 30) & 0x1) == 0)
    588                                             {
    589                                               /* 33222222222211111111110000000000
    590                                                  10987654321098765432109876543210
    591                                                  0000100x110xxxxx1xxxxxxxxxxxxxxx
    592                                                  ldarb.  */
    593                                               return 942;
    594                                             }
    595                                           else
    596                                             {
    597                                               /* 33222222222211111111110000000000
    598                                                  10987654321098765432109876543210
    599                                                  0100100x110xxxxx1xxxxxxxxxxxxxxx
    600                                                  ldarh.  */
    601                                               return 948;
    602                                             }
    603                                         }
    604                                       else
    605                                         {
    606                                           /* 33222222222211111111110000000000
    607                                              10987654321098765432109876543210
    608                                              1x00100x110xxxxx1xxxxxxxxxxxxxxx
    609                                              ldar.  */
    610                                           return 958;
    611                                         }
    612                                     }
    613                                   else
    614                                     {
    615                                       if (((word >> 31) & 0x1) == 0)
    616                                         {
    617                                           if (((word >> 30) & 0x1) == 0)
    618                                             {
    619                                               /* 33222222222211111111110000000000
    620                                                  10987654321098765432109876543210
    621                                                  0000100x111xxxxx1xxxxxxxxxxxxxxx
    622                                                  casalb.  */
    623                                               return 1015;
    624                                             }
    625                                           else
    626                                             {
    627                                               /* 33222222222211111111110000000000
    628                                                  10987654321098765432109876543210
    629                                                  0100100x111xxxxx1xxxxxxxxxxxxxxx
    630                                                  casalh.  */
    631                                               return 1018;
    632                                             }
    633                                         }
    634                                       else
    635                                         {
    636                                           /* 33222222222211111111110000000000
    637                                              10987654321098765432109876543210
    638                                              1x00100x111xxxxx1xxxxxxxxxxxxxxx
    639                                              casal.  */
    640                                           return 1021;
    641                                         }
    642                                     }
    643                                 }
    644                             }
    645                           else
    646                             {
    647                               if (((word >> 30) & 0x1) == 0)
    648                                 {
    649                                   /* 33222222222211111111110000000000
    650                                      10987654321098765432109876543210
    651                                      x010100x11xxxxxxxxxxxxxxxxxxxxxx
    652                                      ldp.  */
    653                                   return 982;
    654                                 }
    655                               else
    656                                 {
    657                                   /* 33222222222211111111110000000000
    658                                      10987654321098765432109876543210
    659                                      x110100x11xxxxxxxxxxxxxxxxxxxxxx
    660                                      ldpsw.  */
    661                                   return 985;
    662                                 }
    663                             }
    664                         }
    665                     }
    666                 }
    667               else
    668                 {
    669                   if (((word >> 24) & 0x1) == 0)
    670                     {
    671                       if (((word >> 29) & 0x1) == 0)
    672                         {
    673                           if (((word >> 31) & 0x1) == 0)
    674                             {
    675                               /* 33222222222211111111110000000000
    676                                  10987654321098765432109876543210
    677                                  0x011000xxxxxxxxxxxxxxxxxxxxxxxx
    678                                  ldr.  */
    679                               return 987;
    680                             }
    681                           else
    682                             {
    683                               if (((word >> 30) & 0x1) == 0)
    684                                 {
    685                                   /* 33222222222211111111110000000000
    686                                      10987654321098765432109876543210
    687                                      10011000xxxxxxxxxxxxxxxxxxxxxxxx
    688                                      ldrsw.  */
    689                                   return 989;
    690                                 }
    691                               else
    692                                 {
    693                                   /* 33222222222211111111110000000000
    694                                      10987654321098765432109876543210
    695                                      11011000xxxxxxxxxxxxxxxxxxxxxxxx
    696                                      prfm.  */
    697                                   return 990;
    698                                 }
    699                             }
    700                         }
    701                       else
    702                         {
    703                           if (((word >> 10) & 0x1) == 0)
    704                             {
    705                               if (((word >> 11) & 0x1) == 0)
    706                                 {
    707                                   if (((word >> 21) & 0x1) == 0)
    708                                     {
    709                                       if (((word >> 23) & 0x1) == 0)
    710                                         {
    711                                           if (((word >> 22) & 0x1) == 0)
    712                                             {
    713                                               if (((word >> 31) & 0x1) == 0)
    714                                                 {
    715                                                   if (((word >> 30) & 0x1) == 0)
    716                                                     {
    717                                                       /* 33222222222211111111110000000000
    718                                                          10987654321098765432109876543210
    719                                                          00111000000xxxxxxxxx00xxxxxxxxxx
    720                                                          sturb.  */
    721                                                       return 922;
    722                                                     }
    723                                                   else
    724                                                     {
    725                                                       /* 33222222222211111111110000000000
    726                                                          10987654321098765432109876543210
    727                                                          01111000000xxxxxxxxx00xxxxxxxxxx
    728                                                          sturh.  */
    729                                                       return 927;
    730                                                     }
    731                                                 }
    732                                               else
    733                                                 {
    734                                                   /* 33222222222211111111110000000000
    735                                                      10987654321098765432109876543210
    736                                                      1x111000000xxxxxxxxx00xxxxxxxxxx
    737                                                      stur.  */
    738                                                   return 930;
    739                                                 }
    740                                             }
    741                                           else
    742                                             {
    743                                               if (((word >> 31) & 0x1) == 0)
    744                                                 {
    745                                                   if (((word >> 30) & 0x1) == 0)
    746                                                     {
    747                                                       /* 33222222222211111111110000000000
    748                                                          10987654321098765432109876543210
    749                                                          00111000010xxxxxxxxx00xxxxxxxxxx
    750                                                          ldurb.  */
    751                                                       return 923;
    752                                                     }
    753                                                   else
    754                                                     {
    755                                                       /* 33222222222211111111110000000000
    756                                                          10987654321098765432109876543210
    757                                                          01111000010xxxxxxxxx00xxxxxxxxxx
    758                                                          ldurh.  */
    759                                                       return 928;
    760                                                     }
    761                                                 }
    762                                               else
    763                                                 {
    764                                                   /* 33222222222211111111110000000000
    765                                                      10987654321098765432109876543210
    766                                                      1x111000010xxxxxxxxx00xxxxxxxxxx
    767                                                      ldur.  */
    768                                                   return 931;
    769                                                 }
    770                                             }
    771                                         }
    772                                       else
    773                                         {
    774                                           if (((word >> 30) & 0x1) == 0)
    775                                             {
    776                                               if (((word >> 31) & 0x1) == 0)
    777                                                 {
    778                                                   /* 33222222222211111111110000000000
    779                                                      10987654321098765432109876543210
    780                                                      001110001x0xxxxxxxxx00xxxxxxxxxx
    781                                                      ldursb.  */
    782                                                   return 924;
    783                                                 }
    784                                               else
    785                                                 {
    786                                                   /* 33222222222211111111110000000000
    787                                                      10987654321098765432109876543210
    788                                                      101110001x0xxxxxxxxx00xxxxxxxxxx
    789                                                      ldursw.  */
    790                                                   return 932;
    791                                                 }
    792                                             }
    793                                           else
    794                                             {
    795                                               if (((word >> 31) & 0x1) == 0)
    796                                                 {
    797                                                   /* 33222222222211111111110000000000
    798                                                      10987654321098765432109876543210
    799                                                      011110001x0xxxxxxxxx00xxxxxxxxxx
    800                                                      ldursh.  */
    801                                                   return 929;
    802                                                 }
    803                                               else
    804                                                 {
    805                                                   /* 33222222222211111111110000000000
    806                                                      10987654321098765432109876543210
    807                                                      111110001x0xxxxxxxxx00xxxxxxxxxx
    808                                                      prfum.  */
    809                                                   return 933;
    810                                                 }
    811                                             }
    812                                         }
    813                                     }
    814                                   else
    815                                     {
    816                                       if (((word >> 12) & 0x1) == 0)
    817                                         {
    818                                           if (((word >> 13) & 0x1) == 0)
    819                                             {
    820                                               if (((word >> 14) & 0x1) == 0)
    821                                                 {
    822                                                   if (((word >> 15) & 0x1) == 0)
    823                                                     {
    824                                                       if (((word >> 22) & 0x1) == 0)
    825                                                         {
    826                                                           if (((word >> 23) & 0x1) == 0)
    827                                                             {
    828                                                               if (((word >> 31) & 0x1) == 0)
    829                                                                 {
    830                                                                   if (((word >> 30) & 0x1) == 0)
    831                                                                     {
    832                                                                       /* 33222222222211111111110000000000
    833                                                                          10987654321098765432109876543210
    834                                                                          00111000001xxxxx000000xxxxxxxxxx
    835                                                                          ldaddb.  */
    836                                                                       return 1038;
    837                                                                     }
    838                                                                   else
    839                                                                     {
    840                                                                       /* 33222222222211111111110000000000
    841                                                                          10987654321098765432109876543210
    842                                                                          01111000001xxxxx000000xxxxxxxxxx
    843                                                                          ldaddh.  */
    844                                                                       return 1039;
    845                                                                     }
    846                                                                 }
    847                                                               else
    848                                                                 {
    849                                                                   /* 33222222222211111111110000000000
    850                                                                      10987654321098765432109876543210
    851                                                                      1x111000001xxxxx000000xxxxxxxxxx
    852                                                                      ldadd.  */
    853                                                                   return 1040;
    854                                                                 }
    855                                                             }
    856                                                           else
    857                                                             {
    858                                                               if (((word >> 31) & 0x1) == 0)
    859                                                                 {
    860                                                                   if (((word >> 30) & 0x1) == 0)
    861                                                                     {
    862                                                                       /* 33222222222211111111110000000000
    863                                                                          10987654321098765432109876543210
    864                                                                          00111000101xxxxx000000xxxxxxxxxx
    865                                                                          ldaddab.  */
    866                                                                       return 1041;
    867                                                                     }
    868                                                                   else
    869                                                                     {
    870                                                                       /* 33222222222211111111110000000000
    871                                                                          10987654321098765432109876543210
    872                                                                          01111000101xxxxx000000xxxxxxxxxx
    873                                                                          ldaddah.  */
    874                                                                       return 1044;
    875                                                                     }
    876                                                                 }
    877                                                               else
    878                                                                 {
    879                                                                   /* 33222222222211111111110000000000
    880                                                                      10987654321098765432109876543210
    881                                                                      1x111000101xxxxx000000xxxxxxxxxx
    882                                                                      ldadda.  */
    883                                                                   return 1047;
    884                                                                 }
    885                                                             }
    886                                                         }
    887                                                       else
    888                                                         {
    889                                                           if (((word >> 23) & 0x1) == 0)
    890                                                             {
    891                                                               if (((word >> 31) & 0x1) == 0)
    892                                                                 {
    893                                                                   if (((word >> 30) & 0x1) == 0)
    894                                                                     {
    895                                                                       /* 33222222222211111111110000000000
    896                                                                          10987654321098765432109876543210
    897                                                                          00111000011xxxxx000000xxxxxxxxxx
    898                                                                          ldaddlb.  */
    899                                                                       return 1042;
    900                                                                     }
    901                                                                   else
    902                                                                     {
    903                                                                       /* 33222222222211111111110000000000
    904                                                                          10987654321098765432109876543210
    905                                                                          01111000011xxxxx000000xxxxxxxxxx
    906                                                                          ldaddlh.  */
    907                                                                       return 1045;
    908                                                                     }
    909                                                                 }
    910                                                               else
    911                                                                 {
    912                                                                   /* 33222222222211111111110000000000
    913                                                                      10987654321098765432109876543210
    914                                                                      1x111000011xxxxx000000xxxxxxxxxx
    915                                                                      ldaddl.  */
    916                                                                   return 1048;
    917                                                                 }
    918                                                             }
    919                                                           else
    920                                                             {
    921                                                               if (((word >> 31) & 0x1) == 0)
    922                                                                 {
    923                                                                   if (((word >> 30) & 0x1) == 0)
    924                                                                     {
    925                                                                       /* 33222222222211111111110000000000
    926                                                                          10987654321098765432109876543210
    927                                                                          00111000111xxxxx000000xxxxxxxxxx
    928                                                                          ldaddalb.  */
    929                                                                       return 1043;
    930                                                                     }
    931                                                                   else
    932                                                                     {
    933                                                                       /* 33222222222211111111110000000000
    934                                                                          10987654321098765432109876543210
    935                                                                          01111000111xxxxx000000xxxxxxxxxx
    936                                                                          ldaddalh.  */
    937                                                                       return 1046;
    938                                                                     }
    939                                                                 }
    940                                                               else
    941                                                                 {
    942                                                                   /* 33222222222211111111110000000000
    943                                                                      10987654321098765432109876543210
    944                                                                      1x111000111xxxxx000000xxxxxxxxxx
    945                                                                      ldaddal.  */
    946                                                                   return 1049;
    947                                                                 }
    948                                                             }
    949                                                         }
    950                                                     }
    951                                                   else
    952                                                     {
    953                                                       if (((word >> 22) & 0x1) == 0)
    954                                                         {
    955                                                           if (((word >> 23) & 0x1) == 0)
    956                                                             {
    957                                                               if (((word >> 31) & 0x1) == 0)
    958                                                                 {
    959                                                                   if (((word >> 30) & 0x1) == 0)
    960                                                                     {
    961                                                                       /* 33222222222211111111110000000000
    962                                                                          10987654321098765432109876543210
    963                                                                          00111000001xxxxx100000xxxxxxxxxx
    964                                                                          swpb.  */
    965                                                                       return 1026;
    966                                                                     }
    967                                                                   else
    968                                                                     {
    969                                                                       /* 33222222222211111111110000000000
    970                                                                          10987654321098765432109876543210
    971                                                                          01111000001xxxxx100000xxxxxxxxxx
    972                                                                          swph.  */
    973                                                                       return 1027;
    974                                                                     }
    975                                                                 }
    976                                                               else
    977                                                                 {
    978                                                                   /* 33222222222211111111110000000000
    979                                                                      10987654321098765432109876543210
    980                                                                      1x111000001xxxxx100000xxxxxxxxxx
    981                                                                      swp.  */
    982                                                                   return 1028;
    983                                                                 }
    984                                                             }
    985                                                           else
    986                                                             {
    987                                                               if (((word >> 31) & 0x1) == 0)
    988                                                                 {
    989                                                                   if (((word >> 30) & 0x1) == 0)
    990                                                                     {
    991                                                                       /* 33222222222211111111110000000000
    992                                                                          10987654321098765432109876543210
    993                                                                          00111000101xxxxx100000xxxxxxxxxx
    994                                                                          swpab.  */
    995                                                                       return 1029;
    996                                                                     }
    997                                                                   else
    998                                                                     {
    999                                                                       /* 33222222222211111111110000000000
   1000                                                                          10987654321098765432109876543210
   1001                                                                          01111000101xxxxx100000xxxxxxxxxx
   1002                                                                          swpah.  */
   1003                                                                       return 1032;
   1004                                                                     }
   1005                                                                 }
   1006                                                               else
   1007                                                                 {
   1008                                                                   /* 33222222222211111111110000000000
   1009                                                                      10987654321098765432109876543210
   1010                                                                      1x111000101xxxxx100000xxxxxxxxxx
   1011                                                                      swpa.  */
   1012                                                                   return 1035;
   1013                                                                 }
   1014                                                             }
   1015                                                         }
   1016                                                       else
   1017                                                         {
   1018                                                           if (((word >> 23) & 0x1) == 0)
   1019                                                             {
   1020                                                               if (((word >> 31) & 0x1) == 0)
   1021                                                                 {
   1022                                                                   if (((word >> 30) & 0x1) == 0)
   1023                                                                     {
   1024                                                                       /* 33222222222211111111110000000000
   1025                                                                          10987654321098765432109876543210
   1026                                                                          00111000011xxxxx100000xxxxxxxxxx
   1027                                                                          swplb.  */
   1028                                                                       return 1030;
   1029                                                                     }
   1030                                                                   else
   1031                                                                     {
   1032                                                                       /* 33222222222211111111110000000000
   1033                                                                          10987654321098765432109876543210
   1034                                                                          01111000011xxxxx100000xxxxxxxxxx
   1035                                                                          swplh.  */
   1036                                                                       return 1033;
   1037                                                                     }
   1038                                                                 }
   1039                                                               else
   1040                                                                 {
   1041                                                                   /* 33222222222211111111110000000000
   1042                                                                      10987654321098765432109876543210
   1043                                                                      1x111000011xxxxx100000xxxxxxxxxx
   1044                                                                      swpl.  */
   1045                                                                   return 1036;
   1046                                                                 }
   1047                                                             }
   1048                                                           else
   1049                                                             {
   1050                                                               if (((word >> 31) & 0x1) == 0)
   1051                                                                 {
   1052                                                                   if (((word >> 30) & 0x1) == 0)
   1053                                                                     {
   1054                                                                       /* 33222222222211111111110000000000
   1055                                                                          10987654321098765432109876543210
   1056                                                                          00111000111xxxxx100000xxxxxxxxxx
   1057                                                                          swpalb.  */
   1058                                                                       return 1031;
   1059                                                                     }
   1060                                                                   else
   1061                                                                     {
   1062                                                                       /* 33222222222211111111110000000000
   1063                                                                          10987654321098765432109876543210
   1064                                                                          01111000111xxxxx100000xxxxxxxxxx
   1065                                                                          swpalh.  */
   1066                                                                       return 1034;
   1067                                                                     }
   1068                                                                 }
   1069                                                               else
   1070                                                                 {
   1071                                                                   /* 33222222222211111111110000000000
   1072                                                                      10987654321098765432109876543210
   1073                                                                      1x111000111xxxxx100000xxxxxxxxxx
   1074                                                                      swpal.  */
   1075                                                                   return 1037;
   1076                                                                 }
   1077                                                             }
   1078                                                         }
   1079                                                     }
   1080                                                 }
   1081                                               else
   1082                                                 {
   1083                                                   if (((word >> 15) & 0x1) == 0)
   1084                                                     {
   1085                                                       if (((word >> 22) & 0x1) == 0)
   1086                                                         {
   1087                                                           if (((word >> 23) & 0x1) == 0)
   1088                                                             {
   1089                                                               if (((word >> 31) & 0x1) == 0)
   1090                                                                 {
   1091                                                                   if (((word >> 30) & 0x1) == 0)
   1092                                                                     {
   1093                                                                       /* 33222222222211111111110000000000
   1094                                                                          10987654321098765432109876543210
   1095                                                                          00111000001xxxxx010000xxxxxxxxxx
   1096                                                                          ldsmaxb.  */
   1097                                                                       return 1086;
   1098                                                                     }
   1099                                                                   else
   1100                                                                     {
   1101                                                                       /* 33222222222211111111110000000000
   1102                                                                          10987654321098765432109876543210
   1103                                                                          01111000001xxxxx010000xxxxxxxxxx
   1104                                                                          ldsmaxh.  */
   1105                                                                       return 1087;
   1106                                                                     }
   1107                                                                 }
   1108                                                               else
   1109                                                                 {
   1110                                                                   /* 33222222222211111111110000000000
   1111                                                                      10987654321098765432109876543210
   1112                                                                      1x111000001xxxxx010000xxxxxxxxxx
   1113                                                                      ldsmax.  */
   1114                                                                   return 1088;
   1115                                                                 }
   1116                                                             }
   1117                                                           else
   1118                                                             {
   1119                                                               if (((word >> 31) & 0x1) == 0)
   1120                                                                 {
   1121                                                                   if (((word >> 30) & 0x1) == 0)
   1122                                                                     {
   1123                                                                       /* 33222222222211111111110000000000
   1124                                                                          10987654321098765432109876543210
   1125                                                                          00111000101xxxxx010000xxxxxxxxxx
   1126                                                                          ldsmaxab.  */
   1127                                                                       return 1089;
   1128                                                                     }
   1129                                                                   else
   1130                                                                     {
   1131                                                                       /* 33222222222211111111110000000000
   1132                                                                          10987654321098765432109876543210
   1133                                                                          01111000101xxxxx010000xxxxxxxxxx
   1134                                                                          ldsmaxah.  */
   1135                                                                       return 1092;
   1136                                                                     }
   1137                                                                 }
   1138                                                               else
   1139                                                                 {
   1140                                                                   /* 33222222222211111111110000000000
   1141                                                                      10987654321098765432109876543210
   1142                                                                      1x111000101xxxxx010000xxxxxxxxxx
   1143                                                                      ldsmaxa.  */
   1144                                                                   return 1095;
   1145                                                                 }
   1146                                                             }
   1147                                                         }
   1148                                                       else
   1149                                                         {
   1150                                                           if (((word >> 23) & 0x1) == 0)
   1151                                                             {
   1152                                                               if (((word >> 31) & 0x1) == 0)
   1153                                                                 {
   1154                                                                   if (((word >> 30) & 0x1) == 0)
   1155                                                                     {
   1156                                                                       /* 33222222222211111111110000000000
   1157                                                                          10987654321098765432109876543210
   1158                                                                          00111000011xxxxx010000xxxxxxxxxx
   1159                                                                          ldsmaxlb.  */
   1160                                                                       return 1090;
   1161                                                                     }
   1162                                                                   else
   1163                                                                     {
   1164                                                                       /* 33222222222211111111110000000000
   1165                                                                          10987654321098765432109876543210
   1166                                                                          01111000011xxxxx010000xxxxxxxxxx
   1167                                                                          ldsmaxlh.  */
   1168                                                                       return 1093;
   1169                                                                     }
   1170                                                                 }
   1171                                                               else
   1172                                                                 {
   1173                                                                   /* 33222222222211111111110000000000
   1174                                                                      10987654321098765432109876543210
   1175                                                                      1x111000011xxxxx010000xxxxxxxxxx
   1176                                                                      ldsmaxl.  */
   1177                                                                   return 1096;
   1178                                                                 }
   1179                                                             }
   1180                                                           else
   1181                                                             {
   1182                                                               if (((word >> 31) & 0x1) == 0)
   1183                                                                 {
   1184                                                                   if (((word >> 30) & 0x1) == 0)
   1185                                                                     {
   1186                                                                       /* 33222222222211111111110000000000
   1187                                                                          10987654321098765432109876543210
   1188                                                                          00111000111xxxxx010000xxxxxxxxxx
   1189                                                                          ldsmaxalb.  */
   1190                                                                       return 1091;
   1191                                                                     }
   1192                                                                   else
   1193                                                                     {
   1194                                                                       /* 33222222222211111111110000000000
   1195                                                                          10987654321098765432109876543210
   1196                                                                          01111000111xxxxx010000xxxxxxxxxx
   1197                                                                          ldsmaxalh.  */
   1198                                                                       return 1094;
   1199                                                                     }
   1200                                                                 }
   1201                                                               else
   1202                                                                 {
   1203                                                                   /* 33222222222211111111110000000000
   1204                                                                      10987654321098765432109876543210
   1205                                                                      1x111000111xxxxx010000xxxxxxxxxx
   1206                                                                      ldsmaxal.  */
   1207                                                                   return 1097;
   1208                                                                 }
   1209                                                             }
   1210                                                         }
   1211                                                     }
   1212                                                   else
   1213                                                     {
   1214                                                       if (((word >> 31) & 0x1) == 0)
   1215                                                         {
   1216                                                           if (((word >> 30) & 0x1) == 0)
   1217                                                             {
   1218                                                               /* 33222222222211111111110000000000
   1219                                                                  10987654321098765432109876543210
   1220                                                                  00111000xx1xxxxx110000xxxxxxxxxx
   1221                                                                  ldaprb.  */
   1222                                                               return 959;
   1223                                                             }
   1224                                                           else
   1225                                                             {
   1226                                                               /* 33222222222211111111110000000000
   1227                                                                  10987654321098765432109876543210
   1228                                                                  01111000xx1xxxxx110000xxxxxxxxxx
   1229                                                                  ldaprh.  */
   1230                                                               return 960;
   1231                                                             }
   1232                                                         }
   1233                                                       else
   1234                                                         {
   1235                                                           /* 33222222222211111111110000000000
   1236                                                              10987654321098765432109876543210
   1237                                                              1x111000xx1xxxxx110000xxxxxxxxxx
   1238                                                              ldapr.  */
   1239                                                           return 961;
   1240                                                         }
   1241                                                     }
   1242                                                 }
   1243                                             }
   1244                                           else
   1245                                             {
   1246                                               if (((word >> 14) & 0x1) == 0)
   1247                                                 {
   1248                                                   if (((word >> 22) & 0x1) == 0)
   1249                                                     {
   1250                                                       if (((word >> 23) & 0x1) == 0)
   1251                                                         {
   1252                                                           if (((word >> 31) & 0x1) == 0)
   1253                                                             {
   1254                                                               if (((word >> 30) & 0x1) == 0)
   1255                                                                 {
   1256                                                                   /* 33222222222211111111110000000000
   1257                                                                      10987654321098765432109876543210
   1258                                                                      00111000001xxxxxx01000xxxxxxxxxx
   1259                                                                      ldeorb.  */
   1260                                                                   return 1062;
   1261                                                                 }
   1262                                                               else
   1263                                                                 {
   1264                                                                   /* 33222222222211111111110000000000
   1265                                                                      10987654321098765432109876543210
   1266                                                                      01111000001xxxxxx01000xxxxxxxxxx
   1267                                                                      ldeorh.  */
   1268                                                                   return 1063;
   1269                                                                 }
   1270                                                             }
   1271                                                           else
   1272                                                             {
   1273                                                               /* 33222222222211111111110000000000
   1274                                                                  10987654321098765432109876543210
   1275                                                                  1x111000001xxxxxx01000xxxxxxxxxx
   1276                                                                  ldeor.  */
   1277                                                               return 1064;
   1278                                                             }
   1279                                                         }
   1280                                                       else
   1281                                                         {
   1282                                                           if (((word >> 31) & 0x1) == 0)
   1283                                                             {
   1284                                                               if (((word >> 30) & 0x1) == 0)
   1285                                                                 {
   1286                                                                   /* 33222222222211111111110000000000
   1287                                                                      10987654321098765432109876543210
   1288                                                                      00111000101xxxxxx01000xxxxxxxxxx
   1289                                                                      ldeorab.  */
   1290                                                                   return 1065;
   1291                                                                 }
   1292                                                               else
   1293                                                                 {
   1294                                                                   /* 33222222222211111111110000000000
   1295                                                                      10987654321098765432109876543210
   1296                                                                      01111000101xxxxxx01000xxxxxxxxxx
   1297                                                                      ldeorah.  */
   1298                                                                   return 1068;
   1299                                                                 }
   1300                                                             }
   1301                                                           else
   1302                                                             {
   1303                                                               /* 33222222222211111111110000000000
   1304                                                                  10987654321098765432109876543210
   1305                                                                  1x111000101xxxxxx01000xxxxxxxxxx
   1306                                                                  ldeora.  */
   1307                                                               return 1071;
   1308                                                             }
   1309                                                         }
   1310                                                     }
   1311                                                   else
   1312                                                     {
   1313                                                       if (((word >> 23) & 0x1) == 0)
   1314                                                         {
   1315                                                           if (((word >> 31) & 0x1) == 0)
   1316                                                             {
   1317                                                               if (((word >> 30) & 0x1) == 0)
   1318                                                                 {
   1319                                                                   /* 33222222222211111111110000000000
   1320                                                                      10987654321098765432109876543210
   1321                                                                      00111000011xxxxxx01000xxxxxxxxxx
   1322                                                                      ldeorlb.  */
   1323                                                                   return 1066;
   1324                                                                 }
   1325                                                               else
   1326                                                                 {
   1327                                                                   /* 33222222222211111111110000000000
   1328                                                                      10987654321098765432109876543210
   1329                                                                      01111000011xxxxxx01000xxxxxxxxxx
   1330                                                                      ldeorlh.  */
   1331                                                                   return 1069;
   1332                                                                 }
   1333                                                             }
   1334                                                           else
   1335                                                             {
   1336                                                               /* 33222222222211111111110000000000
   1337                                                                  10987654321098765432109876543210
   1338                                                                  1x111000011xxxxxx01000xxxxxxxxxx
   1339                                                                  ldeorl.  */
   1340                                                               return 1072;
   1341                                                             }
   1342                                                         }
   1343                                                       else
   1344                                                         {
   1345                                                           if (((word >> 31) & 0x1) == 0)
   1346                                                             {
   1347                                                               if (((word >> 30) & 0x1) == 0)
   1348                                                                 {
   1349                                                                   /* 33222222222211111111110000000000
   1350                                                                      10987654321098765432109876543210
   1351                                                                      00111000111xxxxxx01000xxxxxxxxxx
   1352                                                                      ldeoralb.  */
   1353                                                                   return 1067;
   1354                                                                 }
   1355                                                               else
   1356                                                                 {
   1357                                                                   /* 33222222222211111111110000000000
   1358                                                                      10987654321098765432109876543210
   1359                                                                      01111000111xxxxxx01000xxxxxxxxxx
   1360                                                                      ldeoralh.  */
   1361                                                                   return 1070;
   1362                                                                 }
   1363                                                             }
   1364                                                           else
   1365                                                             {
   1366                                                               /* 33222222222211111111110000000000
   1367                                                                  10987654321098765432109876543210
   1368                                                                  1x111000111xxxxxx01000xxxxxxxxxx
   1369                                                                  ldeoral.  */
   1370                                                               return 1073;
   1371                                                             }
   1372                                                         }
   1373                                                     }
   1374                                                 }
   1375                                               else
   1376                                                 {
   1377                                                   if (((word >> 22) & 0x1) == 0)
   1378                                                     {
   1379                                                       if (((word >> 23) & 0x1) == 0)
   1380                                                         {
   1381                                                           if (((word >> 31) & 0x1) == 0)
   1382                                                             {
   1383                                                               if (((word >> 30) & 0x1) == 0)
   1384                                                                 {
   1385                                                                   /* 33222222222211111111110000000000
   1386                                                                      10987654321098765432109876543210
   1387                                                                      00111000001xxxxxx11000xxxxxxxxxx
   1388                                                                      ldumaxb.  */
   1389                                                                   return 1110;
   1390                                                                 }
   1391                                                               else
   1392                                                                 {
   1393                                                                   /* 33222222222211111111110000000000
   1394                                                                      10987654321098765432109876543210
   1395                                                                      01111000001xxxxxx11000xxxxxxxxxx
   1396                                                                      ldumaxh.  */
   1397                                                                   return 1111;
   1398                                                                 }
   1399                                                             }
   1400                                                           else
   1401                                                             {
   1402                                                               /* 33222222222211111111110000000000
   1403                                                                  10987654321098765432109876543210
   1404                                                                  1x111000001xxxxxx11000xxxxxxxxxx
   1405                                                                  ldumax.  */
   1406                                                               return 1112;
   1407                                                             }
   1408                                                         }
   1409                                                       else
   1410                                                         {
   1411                                                           if (((word >> 31) & 0x1) == 0)
   1412                                                             {
   1413                                                               if (((word >> 30) & 0x1) == 0)
   1414                                                                 {
   1415                                                                   /* 33222222222211111111110000000000
   1416                                                                      10987654321098765432109876543210
   1417                                                                      00111000101xxxxxx11000xxxxxxxxxx
   1418                                                                      ldumaxab.  */
   1419                                                                   return 1113;
   1420                                                                 }
   1421                                                               else
   1422                                                                 {
   1423                                                                   /* 33222222222211111111110000000000
   1424                                                                      10987654321098765432109876543210
   1425                                                                      01111000101xxxxxx11000xxxxxxxxxx
   1426                                                                      ldumaxah.  */
   1427                                                                   return 1116;
   1428                                                                 }
   1429                                                             }
   1430                                                           else
   1431                                                             {
   1432                                                               /* 33222222222211111111110000000000
   1433                                                                  10987654321098765432109876543210
   1434                                                                  1x111000101xxxxxx11000xxxxxxxxxx
   1435                                                                  ldumaxa.  */
   1436                                                               return 1119;
   1437                                                             }
   1438                                                         }
   1439                                                     }
   1440                                                   else
   1441                                                     {
   1442                                                       if (((word >> 23) & 0x1) == 0)
   1443                                                         {
   1444                                                           if (((word >> 31) & 0x1) == 0)
   1445                                                             {
   1446                                                               if (((word >> 30) & 0x1) == 0)
   1447                                                                 {
   1448                                                                   /* 33222222222211111111110000000000
   1449                                                                      10987654321098765432109876543210
   1450                                                                      00111000011xxxxxx11000xxxxxxxxxx
   1451                                                                      ldumaxlb.  */
   1452                                                                   return 1114;
   1453                                                                 }
   1454                                                               else
   1455                                                                 {
   1456                                                                   /* 33222222222211111111110000000000
   1457                                                                      10987654321098765432109876543210
   1458                                                                      01111000011xxxxxx11000xxxxxxxxxx
   1459                                                                      ldumaxlh.  */
   1460                                                                   return 1117;
   1461                                                                 }
   1462                                                             }
   1463                                                           else
   1464                                                             {
   1465                                                               /* 33222222222211111111110000000000
   1466                                                                  10987654321098765432109876543210
   1467                                                                  1x111000011xxxxxx11000xxxxxxxxxx
   1468                                                                  ldumaxl.  */
   1469                                                               return 1120;
   1470                                                             }
   1471                                                         }
   1472                                                       else
   1473                                                         {
   1474                                                           if (((word >> 31) & 0x1) == 0)
   1475                                                             {
   1476                                                               if (((word >> 30) & 0x1) == 0)
   1477                                                                 {
   1478                                                                   /* 33222222222211111111110000000000
   1479                                                                      10987654321098765432109876543210
   1480                                                                      00111000111xxxxxx11000xxxxxxxxxx
   1481                                                                      ldumaxalb.  */
   1482                                                                   return 1115;
   1483                                                                 }
   1484                                                               else
   1485                                                                 {
   1486                                                                   /* 33222222222211111111110000000000
   1487                                                                      10987654321098765432109876543210
   1488                                                                      01111000111xxxxxx11000xxxxxxxxxx
   1489                                                                      ldumaxalh.  */
   1490                                                                   return 1118;
   1491                                                                 }
   1492                                                             }
   1493                                                           else
   1494                                                             {
   1495                                                               /* 33222222222211111111110000000000
   1496                                                                  10987654321098765432109876543210
   1497                                                                  1x111000111xxxxxx11000xxxxxxxxxx
   1498                                                                  ldumaxal.  */
   1499                                                               return 1121;
   1500                                                             }
   1501                                                         }
   1502                                                     }
   1503                                                 }
   1504                                             }
   1505                                         }
   1506                                       else
   1507                                         {
   1508                                           if (((word >> 13) & 0x1) == 0)
   1509                                             {
   1510                                               if (((word >> 14) & 0x1) == 0)
   1511                                                 {
   1512                                                   if (((word >> 22) & 0x1) == 0)
   1513                                                     {
   1514                                                       if (((word >> 23) & 0x1) == 0)
   1515                                                         {
   1516                                                           if (((word >> 31) & 0x1) == 0)
   1517                                                             {
   1518                                                               if (((word >> 30) & 0x1) == 0)
   1519                                                                 {
   1520                                                                   /* 33222222222211111111110000000000
   1521                                                                      10987654321098765432109876543210
   1522                                                                      00111000001xxxxxx00100xxxxxxxxxx
   1523                                                                      ldclrb.  */
   1524                                                                   return 1050;
   1525                                                                 }
   1526                                                               else
   1527                                                                 {
   1528                                                                   /* 33222222222211111111110000000000
   1529                                                                      10987654321098765432109876543210
   1530                                                                      01111000001xxxxxx00100xxxxxxxxxx
   1531                                                                      ldclrh.  */
   1532                                                                   return 1051;
   1533                                                                 }
   1534                                                             }
   1535                                                           else
   1536                                                             {
   1537                                                               /* 33222222222211111111110000000000
   1538                                                                  10987654321098765432109876543210
   1539                                                                  1x111000001xxxxxx00100xxxxxxxxxx
   1540                                                                  ldclr.  */
   1541                                                               return 1052;
   1542                                                             }
   1543                                                         }
   1544                                                       else
   1545                                                         {
   1546                                                           if (((word >> 31) & 0x1) == 0)
   1547                                                             {
   1548                                                               if (((word >> 30) & 0x1) == 0)
   1549                                                                 {
   1550                                                                   /* 33222222222211111111110000000000
   1551                                                                      10987654321098765432109876543210
   1552                                                                      00111000101xxxxxx00100xxxxxxxxxx
   1553                                                                      ldclrab.  */
   1554                                                                   return 1053;
   1555                                                                 }
   1556                                                               else
   1557                                                                 {
   1558                                                                   /* 33222222222211111111110000000000
   1559                                                                      10987654321098765432109876543210
   1560                                                                      01111000101xxxxxx00100xxxxxxxxxx
   1561                                                                      ldclrah.  */
   1562                                                                   return 1056;
   1563                                                                 }
   1564                                                             }
   1565                                                           else
   1566                                                             {
   1567                                                               /* 33222222222211111111110000000000
   1568                                                                  10987654321098765432109876543210
   1569                                                                  1x111000101xxxxxx00100xxxxxxxxxx
   1570                                                                  ldclra.  */
   1571                                                               return 1059;
   1572                                                             }
   1573                                                         }
   1574                                                     }
   1575                                                   else
   1576                                                     {
   1577                                                       if (((word >> 23) & 0x1) == 0)
   1578                                                         {
   1579                                                           if (((word >> 31) & 0x1) == 0)
   1580                                                             {
   1581                                                               if (((word >> 30) & 0x1) == 0)
   1582                                                                 {
   1583                                                                   /* 33222222222211111111110000000000
   1584                                                                      10987654321098765432109876543210
   1585                                                                      00111000011xxxxxx00100xxxxxxxxxx
   1586                                                                      ldclrlb.  */
   1587                                                                   return 1054;
   1588                                                                 }
   1589                                                               else
   1590                                                                 {
   1591                                                                   /* 33222222222211111111110000000000
   1592                                                                      10987654321098765432109876543210
   1593                                                                      01111000011xxxxxx00100xxxxxxxxxx
   1594                                                                      ldclrlh.  */
   1595                                                                   return 1057;
   1596                                                                 }
   1597                                                             }
   1598                                                           else
   1599                                                             {
   1600                                                               /* 33222222222211111111110000000000
   1601                                                                  10987654321098765432109876543210
   1602                                                                  1x111000011xxxxxx00100xxxxxxxxxx
   1603                                                                  ldclrl.  */
   1604                                                               return 1060;
   1605                                                             }
   1606                                                         }
   1607                                                       else
   1608                                                         {
   1609                                                           if (((word >> 31) & 0x1) == 0)
   1610                                                             {
   1611                                                               if (((word >> 30) & 0x1) == 0)
   1612                                                                 {
   1613                                                                   /* 33222222222211111111110000000000
   1614                                                                      10987654321098765432109876543210
   1615                                                                      00111000111xxxxxx00100xxxxxxxxxx
   1616                                                                      ldclralb.  */
   1617                                                                   return 1055;
   1618                                                                 }
   1619                                                               else
   1620                                                                 {
   1621                                                                   /* 33222222222211111111110000000000
   1622                                                                      10987654321098765432109876543210
   1623                                                                      01111000111xxxxxx00100xxxxxxxxxx
   1624                                                                      ldclralh.  */
   1625                                                                   return 1058;
   1626                                                                 }
   1627                                                             }
   1628                                                           else
   1629                                                             {
   1630                                                               /* 33222222222211111111110000000000
   1631                                                                  10987654321098765432109876543210
   1632                                                                  1x111000111xxxxxx00100xxxxxxxxxx
   1633                                                                  ldclral.  */
   1634                                                               return 1061;
   1635                                                             }
   1636                                                         }
   1637                                                     }
   1638                                                 }
   1639                                               else
   1640                                                 {
   1641                                                   if (((word >> 22) & 0x1) == 0)
   1642                                                     {
   1643                                                       if (((word >> 23) & 0x1) == 0)
   1644                                                         {
   1645                                                           if (((word >> 31) & 0x1) == 0)
   1646                                                             {
   1647                                                               if (((word >> 30) & 0x1) == 0)
   1648                                                                 {
   1649                                                                   /* 33222222222211111111110000000000
   1650                                                                      10987654321098765432109876543210
   1651                                                                      00111000001xxxxxx10100xxxxxxxxxx
   1652                                                                      ldsminb.  */
   1653                                                                   return 1098;
   1654                                                                 }
   1655                                                               else
   1656                                                                 {
   1657                                                                   /* 33222222222211111111110000000000
   1658                                                                      10987654321098765432109876543210
   1659                                                                      01111000001xxxxxx10100xxxxxxxxxx
   1660                                                                      ldsminh.  */
   1661                                                                   return 1099;
   1662                                                                 }
   1663                                                             }
   1664                                                           else
   1665                                                             {
   1666                                                               /* 33222222222211111111110000000000
   1667                                                                  10987654321098765432109876543210
   1668                                                                  1x111000001xxxxxx10100xxxxxxxxxx
   1669                                                                  ldsmin.  */
   1670                                                               return 1100;
   1671                                                             }
   1672                                                         }
   1673                                                       else
   1674                                                         {
   1675                                                           if (((word >> 31) & 0x1) == 0)
   1676                                                             {
   1677                                                               if (((word >> 30) & 0x1) == 0)
   1678                                                                 {
   1679                                                                   /* 33222222222211111111110000000000
   1680                                                                      10987654321098765432109876543210
   1681                                                                      00111000101xxxxxx10100xxxxxxxxxx
   1682                                                                      ldsminab.  */
   1683                                                                   return 1101;
   1684                                                                 }
   1685                                                               else
   1686                                                                 {
   1687                                                                   /* 33222222222211111111110000000000
   1688                                                                      10987654321098765432109876543210
   1689                                                                      01111000101xxxxxx10100xxxxxxxxxx
   1690                                                                      ldsminah.  */
   1691                                                                   return 1104;
   1692                                                                 }
   1693                                                             }
   1694                                                           else
   1695                                                             {
   1696                                                               /* 33222222222211111111110000000000
   1697                                                                  10987654321098765432109876543210
   1698                                                                  1x111000101xxxxxx10100xxxxxxxxxx
   1699                                                                  ldsmina.  */
   1700                                                               return 1107;
   1701                                                             }
   1702                                                         }
   1703                                                     }
   1704                                                   else
   1705                                                     {
   1706                                                       if (((word >> 23) & 0x1) == 0)
   1707                                                         {
   1708                                                           if (((word >> 31) & 0x1) == 0)
   1709                                                             {
   1710                                                               if (((word >> 30) & 0x1) == 0)
   1711                                                                 {
   1712                                                                   /* 33222222222211111111110000000000
   1713                                                                      10987654321098765432109876543210
   1714                                                                      00111000011xxxxxx10100xxxxxxxxxx
   1715                                                                      ldsminlb.  */
   1716                                                                   return 1102;
   1717                                                                 }
   1718                                                               else
   1719                                                                 {
   1720                                                                   /* 33222222222211111111110000000000
   1721                                                                      10987654321098765432109876543210
   1722                                                                      01111000011xxxxxx10100xxxxxxxxxx
   1723                                                                      ldsminlh.  */
   1724                                                                   return 1105;
   1725                                                                 }
   1726                                                             }
   1727                                                           else
   1728                                                             {
   1729                                                               /* 33222222222211111111110000000000
   1730                                                                  10987654321098765432109876543210
   1731                                                                  1x111000011xxxxxx10100xxxxxxxxxx
   1732                                                                  ldsminl.  */
   1733                                                               return 1108;
   1734                                                             }
   1735                                                         }
   1736                                                       else
   1737                                                         {
   1738                                                           if (((word >> 31) & 0x1) == 0)
   1739                                                             {
   1740                                                               if (((word >> 30) & 0x1) == 0)
   1741                                                                 {
   1742                                                                   /* 33222222222211111111110000000000
   1743                                                                      10987654321098765432109876543210
   1744                                                                      00111000111xxxxxx10100xxxxxxxxxx
   1745                                                                      ldsminalb.  */
   1746                                                                   return 1103;
   1747                                                                 }
   1748                                                               else
   1749                                                                 {
   1750                                                                   /* 33222222222211111111110000000000
   1751                                                                      10987654321098765432109876543210
   1752                                                                      01111000111xxxxxx10100xxxxxxxxxx
   1753                                                                      ldsminalh.  */
   1754                                                                   return 1106;
   1755                                                                 }
   1756                                                             }
   1757                                                           else
   1758                                                             {
   1759                                                               /* 33222222222211111111110000000000
   1760                                                                  10987654321098765432109876543210
   1761                                                                  1x111000111xxxxxx10100xxxxxxxxxx
   1762                                                                  ldsminal.  */
   1763                                                               return 1109;
   1764                                                             }
   1765                                                         }
   1766                                                     }
   1767                                                 }
   1768                                             }
   1769                                           else
   1770                                             {
   1771                                               if (((word >> 14) & 0x1) == 0)
   1772                                                 {
   1773                                                   if (((word >> 22) & 0x1) == 0)
   1774                                                     {
   1775                                                       if (((word >> 23) & 0x1) == 0)
   1776                                                         {
   1777                                                           if (((word >> 31) & 0x1) == 0)
   1778                                                             {
   1779                                                               if (((word >> 30) & 0x1) == 0)
   1780                                                                 {
   1781                                                                   /* 33222222222211111111110000000000
   1782                                                                      10987654321098765432109876543210
   1783                                                                      00111000001xxxxxx01100xxxxxxxxxx
   1784                                                                      ldsetb.  */
   1785                                                                   return 1074;
   1786                                                                 }
   1787                                                               else
   1788                                                                 {
   1789                                                                   /* 33222222222211111111110000000000
   1790                                                                      10987654321098765432109876543210
   1791                                                                      01111000001xxxxxx01100xxxxxxxxxx
   1792                                                                      ldseth.  */
   1793                                                                   return 1075;
   1794                                                                 }
   1795                                                             }
   1796                                                           else
   1797                                                             {
   1798                                                               /* 33222222222211111111110000000000
   1799                                                                  10987654321098765432109876543210
   1800                                                                  1x111000001xxxxxx01100xxxxxxxxxx
   1801                                                                  ldset.  */
   1802                                                               return 1076;
   1803                                                             }
   1804                                                         }
   1805                                                       else
   1806                                                         {
   1807                                                           if (((word >> 31) & 0x1) == 0)
   1808                                                             {
   1809                                                               if (((word >> 30) & 0x1) == 0)
   1810                                                                 {
   1811                                                                   /* 33222222222211111111110000000000
   1812                                                                      10987654321098765432109876543210
   1813                                                                      00111000101xxxxxx01100xxxxxxxxxx
   1814                                                                      ldsetab.  */
   1815                                                                   return 1077;
   1816                                                                 }
   1817                                                               else
   1818                                                                 {
   1819                                                                   /* 33222222222211111111110000000000
   1820                                                                      10987654321098765432109876543210
   1821                                                                      01111000101xxxxxx01100xxxxxxxxxx
   1822                                                                      ldsetah.  */
   1823                                                                   return 1080;
   1824                                                                 }
   1825                                                             }
   1826                                                           else
   1827                                                             {
   1828                                                               /* 33222222222211111111110000000000
   1829                                                                  10987654321098765432109876543210
   1830                                                                  1x111000101xxxxxx01100xxxxxxxxxx
   1831                                                                  ldseta.  */
   1832                                                               return 1083;
   1833                                                             }
   1834                                                         }
   1835                                                     }
   1836                                                   else
   1837                                                     {
   1838                                                       if (((word >> 23) & 0x1) == 0)
   1839                                                         {
   1840                                                           if (((word >> 31) & 0x1) == 0)
   1841                                                             {
   1842                                                               if (((word >> 30) & 0x1) == 0)
   1843                                                                 {
   1844                                                                   /* 33222222222211111111110000000000
   1845                                                                      10987654321098765432109876543210
   1846                                                                      00111000011xxxxxx01100xxxxxxxxxx
   1847                                                                      ldsetlb.  */
   1848                                                                   return 1078;
   1849                                                                 }
   1850                                                               else
   1851                                                                 {
   1852                                                                   /* 33222222222211111111110000000000
   1853                                                                      10987654321098765432109876543210
   1854                                                                      01111000011xxxxxx01100xxxxxxxxxx
   1855                                                                      ldsetlh.  */
   1856                                                                   return 1081;
   1857                                                                 }
   1858                                                             }
   1859                                                           else
   1860                                                             {
   1861                                                               /* 33222222222211111111110000000000
   1862                                                                  10987654321098765432109876543210
   1863                                                                  1x111000011xxxxxx01100xxxxxxxxxx
   1864                                                                  ldsetl.  */
   1865                                                               return 1084;
   1866                                                             }
   1867                                                         }
   1868                                                       else
   1869                                                         {
   1870                                                           if (((word >> 31) & 0x1) == 0)
   1871                                                             {
   1872                                                               if (((word >> 30) & 0x1) == 0)
   1873                                                                 {
   1874                                                                   /* 33222222222211111111110000000000
   1875                                                                      10987654321098765432109876543210
   1876                                                                      00111000111xxxxxx01100xxxxxxxxxx
   1877                                                                      ldsetalb.  */
   1878                                                                   return 1079;
   1879                                                                 }
   1880                                                               else
   1881                                                                 {
   1882                                                                   /* 33222222222211111111110000000000
   1883                                                                      10987654321098765432109876543210
   1884                                                                      01111000111xxxxxx01100xxxxxxxxxx
   1885                                                                      ldsetalh.  */
   1886                                                                   return 1082;
   1887                                                                 }
   1888                                                             }
   1889                                                           else
   1890                                                             {
   1891                                                               /* 33222222222211111111110000000000
   1892                                                                  10987654321098765432109876543210
   1893                                                                  1x111000111xxxxxx01100xxxxxxxxxx
   1894                                                                  ldsetal.  */
   1895                                                               return 1085;
   1896                                                             }
   1897                                                         }
   1898                                                     }
   1899                                                 }
   1900                                               else
   1901                                                 {
   1902                                                   if (((word >> 22) & 0x1) == 0)
   1903                                                     {
   1904                                                       if (((word >> 23) & 0x1) == 0)
   1905                                                         {
   1906                                                           if (((word >> 31) & 0x1) == 0)
   1907                                                             {
   1908                                                               if (((word >> 30) & 0x1) == 0)
   1909                                                                 {
   1910                                                                   /* 33222222222211111111110000000000
   1911                                                                      10987654321098765432109876543210
   1912                                                                      00111000001xxxxxx11100xxxxxxxxxx
   1913                                                                      lduminb.  */
   1914                                                                   return 1122;
   1915                                                                 }
   1916                                                               else
   1917                                                                 {
   1918                                                                   /* 33222222222211111111110000000000
   1919                                                                      10987654321098765432109876543210
   1920                                                                      01111000001xxxxxx11100xxxxxxxxxx
   1921                                                                      lduminh.  */
   1922                                                                   return 1123;
   1923                                                                 }
   1924                                                             }
   1925                                                           else
   1926                                                             {
   1927                                                               /* 33222222222211111111110000000000
   1928                                                                  10987654321098765432109876543210
   1929                                                                  1x111000001xxxxxx11100xxxxxxxxxx
   1930                                                                  ldumin.  */
   1931                                                               return 1124;
   1932                                                             }
   1933                                                         }
   1934                                                       else
   1935                                                         {
   1936                                                           if (((word >> 31) & 0x1) == 0)
   1937                                                             {
   1938                                                               if (((word >> 30) & 0x1) == 0)
   1939                                                                 {
   1940                                                                   /* 33222222222211111111110000000000
   1941                                                                      10987654321098765432109876543210
   1942                                                                      00111000101xxxxxx11100xxxxxxxxxx
   1943                                                                      lduminab.  */
   1944                                                                   return 1125;
   1945                                                                 }
   1946                                                               else
   1947                                                                 {
   1948                                                                   /* 33222222222211111111110000000000
   1949                                                                      10987654321098765432109876543210
   1950                                                                      01111000101xxxxxx11100xxxxxxxxxx
   1951                                                                      lduminah.  */
   1952                                                                   return 1128;
   1953                                                                 }
   1954                                                             }
   1955                                                           else
   1956                                                             {
   1957                                                               /* 33222222222211111111110000000000
   1958                                                                  10987654321098765432109876543210
   1959                                                                  1x111000101xxxxxx11100xxxxxxxxxx
   1960                                                                  ldumina.  */
   1961                                                               return 1131;
   1962                                                             }
   1963                                                         }
   1964                                                     }
   1965                                                   else
   1966                                                     {
   1967                                                       if (((word >> 23) & 0x1) == 0)
   1968                                                         {
   1969                                                           if (((word >> 31) & 0x1) == 0)
   1970                                                             {
   1971                                                               if (((word >> 30) & 0x1) == 0)
   1972                                                                 {
   1973                                                                   /* 33222222222211111111110000000000
   1974                                                                      10987654321098765432109876543210
   1975                                                                      00111000011xxxxxx11100xxxxxxxxxx
   1976                                                                      lduminlb.  */
   1977                                                                   return 1126;
   1978                                                                 }
   1979                                                               else
   1980                                                                 {
   1981                                                                   /* 33222222222211111111110000000000
   1982                                                                      10987654321098765432109876543210
   1983                                                                      01111000011xxxxxx11100xxxxxxxxxx
   1984                                                                      lduminlh.  */
   1985                                                                   return 1129;
   1986                                                                 }
   1987                                                             }
   1988                                                           else
   1989                                                             {
   1990                                                               /* 33222222222211111111110000000000
   1991                                                                  10987654321098765432109876543210
   1992                                                                  1x111000011xxxxxx11100xxxxxxxxxx
   1993                                                                  lduminl.  */
   1994                                                               return 1132;
   1995                                                             }
   1996                                                         }
   1997                                                       else
   1998                                                         {
   1999                                                           if (((word >> 31) & 0x1) == 0)
   2000                                                             {
   2001                                                               if (((word >> 30) & 0x1) == 0)
   2002                                                                 {
   2003                                                                   /* 33222222222211111111110000000000
   2004                                                                      10987654321098765432109876543210
   2005                                                                      00111000111xxxxxx11100xxxxxxxxxx
   2006                                                                      lduminalb.  */
   2007                                                                   return 1127;
   2008                                                                 }
   2009                                                               else
   2010                                                                 {
   2011                                                                   /* 33222222222211111111110000000000
   2012                                                                      10987654321098765432109876543210
   2013                                                                      01111000111xxxxxx11100xxxxxxxxxx
   2014                                                                      lduminalh.  */
   2015                                                                   return 1130;
   2016                                                                 }
   2017                                                             }
   2018                                                           else
   2019                                                             {
   2020                                                               /* 33222222222211111111110000000000
   2021                                                                  10987654321098765432109876543210
   2022                                                                  1x111000111xxxxxx11100xxxxxxxxxx
   2023                                                                  lduminal.  */
   2024                                                               return 1133;
   2025                                                             }
   2026                                                         }
   2027                                                     }
   2028                                                 }
   2029                                             }
   2030                                         }
   2031                                     }
   2032                                 }
   2033                               else
   2034                                 {
   2035                                   if (((word >> 21) & 0x1) == 0)
   2036                                     {
   2037                                       if (((word >> 23) & 0x1) == 0)
   2038                                         {
   2039                                           if (((word >> 22) & 0x1) == 0)
   2040                                             {
   2041                                               if (((word >> 31) & 0x1) == 0)
   2042                                                 {
   2043                                                   if (((word >> 30) & 0x1) == 0)
   2044                                                     {
   2045                                                       /* 33222222222211111111110000000000
   2046                                                          10987654321098765432109876543210
   2047                                                          00111000000xxxxxxxxx10xxxxxxxxxx
   2048                                                          sttrb.  */
   2049                                                       return 913;
   2050                                                     }
   2051                                                   else
   2052                                                     {
   2053                                                       /* 33222222222211111111110000000000
   2054                                                          10987654321098765432109876543210
   2055                                                          01111000000xxxxxxxxx10xxxxxxxxxx
   2056                                                          sttrh.  */
   2057                                                       return 916;
   2058                                                     }
   2059                                                 }
   2060                                               else
   2061                                                 {
   2062                                                   /* 33222222222211111111110000000000
   2063                                                      10987654321098765432109876543210
   2064                                                      1x111000000xxxxxxxxx10xxxxxxxxxx
   2065                                                      sttr.  */
   2066                                                   return 919;
   2067                                                 }
   2068                                             }
   2069                                           else
   2070                                             {
   2071                                               if (((word >> 31) & 0x1) == 0)
   2072                                                 {
   2073                                                   if (((word >> 30) & 0x1) == 0)
   2074                                                     {
   2075                                                       /* 33222222222211111111110000000000
   2076                                                          10987654321098765432109876543210
   2077                                                          00111000010xxxxxxxxx10xxxxxxxxxx
   2078                                                          ldtrb.  */
   2079                                                       return 914;
   2080                                                     }
   2081                                                   else
   2082                                                     {
   2083                                                       /* 33222222222211111111110000000000
   2084                                                          10987654321098765432109876543210
   2085                                                          01111000010xxxxxxxxx10xxxxxxxxxx
   2086                                                          ldtrh.  */
   2087                                                       return 917;
   2088                                                     }
   2089                                                 }
   2090                                               else
   2091                                                 {
   2092                                                   /* 33222222222211111111110000000000
   2093                                                      10987654321098765432109876543210
   2094                                                      1x111000010xxxxxxxxx10xxxxxxxxxx
   2095                                                      ldtr.  */
   2096                                                   return 920;
   2097                                                 }
   2098                                             }
   2099                                         }
   2100                                       else
   2101                                         {
   2102                                           if (((word >> 30) & 0x1) == 0)
   2103                                             {
   2104                                               if (((word >> 31) & 0x1) == 0)
   2105                                                 {
   2106                                                   /* 33222222222211111111110000000000
   2107                                                      10987654321098765432109876543210
   2108                                                      001110001x0xxxxxxxxx10xxxxxxxxxx
   2109                                                      ldtrsb.  */
   2110                                                   return 915;
   2111                                                 }
   2112                                               else
   2113                                                 {
   2114                                                   /* 33222222222211111111110000000000
   2115                                                      10987654321098765432109876543210
   2116                                                      101110001x0xxxxxxxxx10xxxxxxxxxx
   2117                                                      ldtrsw.  */
   2118                                                   return 921;
   2119                                                 }
   2120                                             }
   2121                                           else
   2122                                             {
   2123                                               /* 33222222222211111111110000000000
   2124                                                  10987654321098765432109876543210
   2125                                                  x11110001x0xxxxxxxxx10xxxxxxxxxx
   2126                                                  ldtrsh.  */
   2127                                               return 918;
   2128                                             }
   2129                                         }
   2130                                     }
   2131                                   else
   2132                                     {
   2133                                       if (((word >> 23) & 0x1) == 0)
   2134                                         {
   2135                                           if (((word >> 22) & 0x1) == 0)
   2136                                             {
   2137                                               if (((word >> 31) & 0x1) == 0)
   2138                                                 {
   2139                                                   if (((word >> 30) & 0x1) == 0)
   2140                                                     {
   2141                                                       /* 33222222222211111111110000000000
   2142                                                          10987654321098765432109876543210
   2143                                                          00111000001xxxxxxxxx10xxxxxxxxxx
   2144                                                          strb.  */
   2145                                                       return 901;
   2146                                                     }
   2147                                                   else
   2148                                                     {
   2149                                                       /* 33222222222211111111110000000000
   2150                                                          10987654321098765432109876543210
   2151                                                          01111000001xxxxxxxxx10xxxxxxxxxx
   2152                                                          strh.  */
   2153                                                       return 906;
   2154                                                     }
   2155                                                 }
   2156                                               else
   2157                                                 {
   2158                                                   /* 33222222222211111111110000000000
   2159                                                      10987654321098765432109876543210
   2160                                                      1x111000001xxxxxxxxx10xxxxxxxxxx
   2161                                                      str.  */
   2162                                                   return 909;
   2163                                                 }
   2164                                             }
   2165                                           else
   2166                                             {
   2167                                               if (((word >> 31) & 0x1) == 0)
   2168                                                 {
   2169                                                   if (((word >> 30) & 0x1) == 0)
   2170                                                     {
   2171                                                       /* 33222222222211111111110000000000
   2172                                                          10987654321098765432109876543210
   2173                                                          00111000011xxxxxxxxx10xxxxxxxxxx
   2174                                                          ldrb.  */
   2175                                                       return 902;
   2176                                                     }
   2177                                                   else
   2178                                                     {
   2179                                                       /* 33222222222211111111110000000000
   2180                                                          10987654321098765432109876543210
   2181                                                          01111000011xxxxxxxxx10xxxxxxxxxx
   2182                                                          ldrh.  */
   2183                                                       return 907;
   2184                                                     }
   2185                                                 }
   2186                                               else
   2187                                                 {
   2188                                                   /* 33222222222211111111110000000000
   2189                                                      10987654321098765432109876543210
   2190                                                      1x111000011xxxxxxxxx10xxxxxxxxxx
   2191                                                      ldr.  */
   2192                                                   return 910;
   2193                                                 }
   2194                                             }
   2195                                         }
   2196                                       else
   2197                                         {
   2198                                           if (((word >> 30) & 0x1) == 0)
   2199                                             {
   2200                                               if (((word >> 31) & 0x1) == 0)
   2201                                                 {
   2202                                                   /* 33222222222211111111110000000000
   2203                                                      10987654321098765432109876543210
   2204                                                      001110001x1xxxxxxxxx10xxxxxxxxxx
   2205                                                      ldrsb.  */
   2206                                                   return 903;
   2207                                                 }
   2208                                               else
   2209                                                 {
   2210                                                   /* 33222222222211111111110000000000
   2211                                                      10987654321098765432109876543210
   2212                                                      101110001x1xxxxxxxxx10xxxxxxxxxx
   2213                                                      ldrsw.  */
   2214                                                   return 911;
   2215                                                 }
   2216                                             }
   2217                                           else
   2218                                             {
   2219                                               if (((word >> 31) & 0x1) == 0)
   2220                                                 {
   2221                                                   /* 33222222222211111111110000000000
   2222                                                      10987654321098765432109876543210
   2223                                                      011110001x1xxxxxxxxx10xxxxxxxxxx
   2224                                                      ldrsh.  */
   2225                                                   return 908;
   2226                                                 }
   2227                                               else
   2228                                                 {
   2229                                                   /* 33222222222211111111110000000000
   2230                                                      10987654321098765432109876543210
   2231                                                      111110001x1xxxxxxxxx10xxxxxxxxxx
   2232                                                      prfm.  */
   2233                                                   return 912;
   2234                                                 }
   2235                                             }
   2236                                         }
   2237                                     }
   2238                                 }
   2239                             }
   2240                           else
   2241                             {
   2242                               if (((word >> 21) & 0x1) == 0)
   2243                                 {
   2244                                   if (((word >> 23) & 0x1) == 0)
   2245                                     {
   2246                                       if (((word >> 22) & 0x1) == 0)
   2247                                         {
   2248                                           if (((word >> 31) & 0x1) == 0)
   2249                                             {
   2250                                               if (((word >> 30) & 0x1) == 0)
   2251                                                 {
   2252                                                   /* 33222222222211111111110000000000
   2253                                                      10987654321098765432109876543210
   2254                                                      00111000000xxxxxxxxxx1xxxxxxxxxx
   2255                                                      strb.  */
   2256                                                   return 870;
   2257                                                 }
   2258                                               else
   2259                                                 {
   2260                                                   /* 33222222222211111111110000000000
   2261                                                      10987654321098765432109876543210
   2262                                                      01111000000xxxxxxxxxx1xxxxxxxxxx
   2263                                                      strh.  */
   2264                                                   return 875;
   2265                                                 }
   2266                                             }
   2267                                           else
   2268                                             {
   2269                                               /* 33222222222211111111110000000000
   2270                                                  10987654321098765432109876543210
   2271                                                  1x111000000xxxxxxxxxx1xxxxxxxxxx
   2272                                                  str.  */
   2273                                               return 878;
   2274                                             }
   2275                                         }
   2276                                       else
   2277                                         {
   2278                                           if (((word >> 31) & 0x1) == 0)
   2279                                             {
   2280                                               if (((word >> 30) & 0x1) == 0)
   2281                                                 {
   2282                                                   /* 33222222222211111111110000000000
   2283                                                      10987654321098765432109876543210
   2284                                                      00111000010xxxxxxxxxx1xxxxxxxxxx
   2285                                                      ldrb.  */
   2286                                                   return 871;
   2287                                                 }
   2288                                               else
   2289                                                 {
   2290                                                   /* 33222222222211111111110000000000
   2291                                                      10987654321098765432109876543210
   2292                                                      01111000010xxxxxxxxxx1xxxxxxxxxx
   2293                                                      ldrh.  */
   2294                                                   return 876;
   2295                                                 }
   2296                                             }
   2297                                           else
   2298                                             {
   2299                                               /* 33222222222211111111110000000000
   2300                                                  10987654321098765432109876543210
   2301                                                  1x111000010xxxxxxxxxx1xxxxxxxxxx
   2302                                                  ldr.  */
   2303                                               return 879;
   2304                                             }
   2305                                         }
   2306                                     }
   2307                                   else
   2308                                     {
   2309                                       if (((word >> 30) & 0x1) == 0)
   2310                                         {
   2311                                           if (((word >> 31) & 0x1) == 0)
   2312                                             {
   2313                                               /* 33222222222211111111110000000000
   2314                                                  10987654321098765432109876543210
   2315                                                  001110001x0xxxxxxxxxx1xxxxxxxxxx
   2316                                                  ldrsb.  */
   2317                                               return 872;
   2318                                             }
   2319                                           else
   2320                                             {
   2321                                               /* 33222222222211111111110000000000
   2322                                                  10987654321098765432109876543210
   2323                                                  101110001x0xxxxxxxxxx1xxxxxxxxxx
   2324                                                  ldrsw.  */
   2325                                               return 880;
   2326                                             }
   2327                                         }
   2328                                       else
   2329                                         {
   2330                                           /* 33222222222211111111110000000000
   2331                                              10987654321098765432109876543210
   2332                                              x11110001x0xxxxxxxxxx1xxxxxxxxxx
   2333                                              ldrsh.  */
   2334                                           return 877;
   2335                                         }
   2336                                     }
   2337                                 }
   2338                               else
   2339                                 {
   2340                                   if (((word >> 23) & 0x1) == 0)
   2341                                     {
   2342                                       /* 33222222222211111111110000000000
   2343                                          10987654321098765432109876543210
   2344                                          xx1110000x1xxxxxxxxxx1xxxxxxxxxx
   2345                                          ldraa.  */
   2346                                       return 935;
   2347                                     }
   2348                                   else
   2349                                     {
   2350                                       /* 33222222222211111111110000000000
   2351                                          10987654321098765432109876543210
   2352                                          xx1110001x1xxxxxxxxxx1xxxxxxxxxx
   2353                                          ldrab.  */
   2354                                       return 936;
   2355                                     }
   2356                                 }
   2357                             }
   2358                         }
   2359                     }
   2360                   else
   2361                     {
   2362                       if (((word >> 23) & 0x1) == 0)
   2363                         {
   2364                           if (((word >> 22) & 0x1) == 0)
   2365                             {
   2366                               if (((word >> 29) & 0x1) == 0)
   2367                                 {
   2368                                   if (((word >> 10) & 0x1) == 0)
   2369                                     {
   2370                                       if (((word >> 11) & 0x1) == 0)
   2371                                         {
   2372                                           if (((word >> 21) & 0x1) == 0)
   2373                                             {
   2374                                               if (((word >> 30) & 0x1) == 0)
   2375                                                 {
   2376                                                   if (((word >> 31) & 0x1) == 0)
   2377                                                     {
   2378                                                       /* 33222222222211111111110000000000
   2379                                                          10987654321098765432109876543210
   2380                                                          00011001000xxxxxxxxx00xxxxxxxxxx
   2381                                                          stlurb.  */
   2382                                                       return 2381;
   2383                                                     }
   2384                                                   else
   2385                                                     {
   2386                                                       /* 33222222222211111111110000000000
   2387                                                          10987654321098765432109876543210
   2388                                                          10011001000xxxxxxxxx00xxxxxxxxxx
   2389                                                          stlur.  */
   2390                                                       return 2389;
   2391                                                     }
   2392                                                 }
   2393                                               else
   2394                                                 {
   2395                                                   if (((word >> 31) & 0x1) == 0)
   2396                                                     {
   2397                                                       /* 33222222222211111111110000000000
   2398                                                          10987654321098765432109876543210
   2399                                                          01011001000xxxxxxxxx00xxxxxxxxxx
   2400                                                          stlurh.  */
   2401                                                       return 2385;
   2402                                                     }
   2403                                                   else
   2404                                                     {
   2405                                                       /* 33222222222211111111110000000000
   2406                                                          10987654321098765432109876543210
   2407                                                          11011001000xxxxxxxxx00xxxxxxxxxx
   2408                                                          stlur.  */
   2409                                                       return 2392;
   2410                                                     }
   2411                                                 }
   2412                                             }
   2413                                           else
   2414                                             {
   2415                                               /* 33222222222211111111110000000000
   2416                                                  10987654321098765432109876543210
   2417                                                  xx011001001xxxxxxxxx00xxxxxxxxxx
   2418                                                  stzgm.  */
   2419                                               return 964;
   2420                                             }
   2421                                         }
   2422                                       else
   2423                                         {
   2424                                           /* 33222222222211111111110000000000
   2425                                              10987654321098765432109876543210
   2426                                              xx01100100xxxxxxxxxx10xxxxxxxxxx
   2427                                              stg.  */
   2428                                           return 881;
   2429                                         }
   2430                                     }
   2431                                   else
   2432                                     {
   2433                                       /* 33222222222211111111110000000000
   2434                                          10987654321098765432109876543210
   2435                                          xx01100100xxxxxxxxxxx1xxxxxxxxxx
   2436                                          stg.  */
   2437                                       return 885;
   2438                                     }
   2439                                 }
   2440                               else
   2441                                 {
   2442                                   if (((word >> 31) & 0x1) == 0)
   2443                                     {
   2444                                       if (((word >> 30) & 0x1) == 0)
   2445                                         {
   2446                                           /* 33222222222211111111110000000000
   2447                                              10987654321098765432109876543210
   2448                                              0011100100xxxxxxxxxxxxxxxxxxxxxx
   2449                                              strb.  */
   2450                                           return 889;
   2451                                         }
   2452                                       else
   2453                                         {
   2454                                           /* 33222222222211111111110000000000
   2455                                              10987654321098765432109876543210
   2456                                              0111100100xxxxxxxxxxxxxxxxxxxxxx
   2457                                              strh.  */
   2458                                           return 894;
   2459                                         }
   2460                                     }
   2461                                   else
   2462                                     {
   2463                                       /* 33222222222211111111110000000000
   2464                                          10987654321098765432109876543210
   2465                                          1x11100100xxxxxxxxxxxxxxxxxxxxxx
   2466                                          str.  */
   2467                                       return 897;
   2468                                     }
   2469                                 }
   2470                             }
   2471                           else
   2472                             {
   2473                               if (((word >> 29) & 0x1) == 0)
   2474                                 {
   2475                                   if (((word >> 10) & 0x1) == 0)
   2476                                     {
   2477                                       if (((word >> 11) & 0x1) == 0)
   2478                                         {
   2479                                           if (((word >> 21) & 0x1) == 0)
   2480                                             {
   2481                                               if (((word >> 30) & 0x1) == 0)
   2482                                                 {
   2483                                                   if (((word >> 31) & 0x1) == 0)
   2484                                                     {
   2485                                                       /* 33222222222211111111110000000000
   2486                                                          10987654321098765432109876543210
   2487                                                          00011001010xxxxxxxxx00xxxxxxxxxx
   2488                                                          ldapurb.  */
   2489                                                       return 2382;
   2490                                                     }
   2491                                                   else
   2492                                                     {
   2493                                                       /* 33222222222211111111110000000000
   2494                                                          10987654321098765432109876543210
   2495                                                          10011001010xxxxxxxxx00xxxxxxxxxx
   2496                                                          ldapur.  */
   2497                                                       return 2390;
   2498                                                     }
   2499                                                 }
   2500                                               else
   2501                                                 {
   2502                                                   if (((word >> 31) & 0x1) == 0)
   2503                                                     {
   2504                                                       /* 33222222222211111111110000000000
   2505                                                          10987654321098765432109876543210
   2506                                                          01011001010xxxxxxxxx00xxxxxxxxxx
   2507                                                          ldapurh.  */
   2508                                                       return 2386;
   2509                                                     }
   2510                                                   else
   2511                                                     {
   2512                                                       /* 33222222222211111111110000000000
   2513                                                          10987654321098765432109876543210
   2514                                                          11011001010xxxxxxxxx00xxxxxxxxxx
   2515                                                          ldapur.  */
   2516                                                       return 2393;
   2517                                                     }
   2518                                                 }
   2519                                             }
   2520                                           else
   2521                                             {
   2522                                               /* 33222222222211111111110000000000
   2523                                                  10987654321098765432109876543210
   2524                                                  xx011001011xxxxxxxxx00xxxxxxxxxx
   2525                                                  ldg.  */
   2526                                               return 934;
   2527                                             }
   2528                                         }
   2529                                       else
   2530                                         {
   2531                                           /* 33222222222211111111110000000000
   2532                                              10987654321098765432109876543210
   2533                                              xx01100101xxxxxxxxxx10xxxxxxxxxx
   2534                                              stzg.  */
   2535                                           return 882;
   2536                                         }
   2537                                     }
   2538                                   else
   2539                                     {
   2540                                       /* 33222222222211111111110000000000
   2541                                          10987654321098765432109876543210
   2542                                          xx01100101xxxxxxxxxxx1xxxxxxxxxx
   2543                                          stzg.  */
   2544                                       return 886;
   2545                                     }
   2546                                 }
   2547                               else
   2548                                 {
   2549                                   if (((word >> 31) & 0x1) == 0)
   2550                                     {
   2551                                       if (((word >> 30) & 0x1) == 0)
   2552                                         {
   2553                                           /* 33222222222211111111110000000000
   2554                                              10987654321098765432109876543210
   2555                                              0011100101xxxxxxxxxxxxxxxxxxxxxx
   2556                                              ldrb.  */
   2557                                           return 890;
   2558                                         }
   2559                                       else
   2560                                         {
   2561                                           /* 33222222222211111111110000000000
   2562                                              10987654321098765432109876543210
   2563                                              0111100101xxxxxxxxxxxxxxxxxxxxxx
   2564                                              ldrh.  */
   2565                                           return 895;
   2566                                         }
   2567                                     }
   2568                                   else
   2569                                     {
   2570                                       /* 33222222222211111111110000000000
   2571                                          10987654321098765432109876543210
   2572                                          1x11100101xxxxxxxxxxxxxxxxxxxxxx
   2573                                          ldr.  */
   2574                                       return 898;
   2575                                     }
   2576                                 }
   2577                             }
   2578                         }
   2579                       else
   2580                         {
   2581                           if (((word >> 29) & 0x1) == 0)
   2582                             {
   2583                               if (((word >> 10) & 0x1) == 0)
   2584                                 {
   2585                                   if (((word >> 11) & 0x1) == 0)
   2586                                     {
   2587                                       if (((word >> 21) & 0x1) == 0)
   2588                                         {
   2589                                           if (((word >> 22) & 0x1) == 0)
   2590                                             {
   2591                                               if (((word >> 30) & 0x1) == 0)
   2592                                                 {
   2593                                                   if (((word >> 31) & 0x1) == 0)
   2594                                                     {
   2595                                                       /* 33222222222211111111110000000000
   2596                                                          10987654321098765432109876543210
   2597                                                          00011001100xxxxxxxxx00xxxxxxxxxx
   2598                                                          ldapursb.  */
   2599                                                       return 2384;
   2600                                                     }
   2601                                                   else
   2602                                                     {
   2603                                                       /* 33222222222211111111110000000000
   2604                                                          10987654321098765432109876543210
   2605                                                          10011001100xxxxxxxxx00xxxxxxxxxx
   2606                                                          ldapursw.  */
   2607                                                       return 2391;
   2608                                                     }
   2609                                                 }
   2610                                               else
   2611                                                 {
   2612                                                   /* 33222222222211111111110000000000
   2613                                                      10987654321098765432109876543210
   2614                                                      x1011001100xxxxxxxxx00xxxxxxxxxx
   2615                                                      ldapursh.  */
   2616                                                   return 2388;
   2617                                                 }
   2618                                             }
   2619                                           else
   2620                                             {
   2621                                               if (((word >> 30) & 0x1) == 0)
   2622                                                 {
   2623                                                   /* 33222222222211111111110000000000
   2624                                                      10987654321098765432109876543210
   2625                                                      x0011001110xxxxxxxxx00xxxxxxxxxx
   2626                                                      ldapursb.  */
   2627                                                   return 2383;
   2628                                                 }
   2629                                               else
   2630                                                 {
   2631                                                   /* 33222222222211111111110000000000
   2632                                                      10987654321098765432109876543210
   2633                                                      x1011001110xxxxxxxxx00xxxxxxxxxx
   2634                                                      ldapursh.  */
   2635                                                   return 2387;
   2636                                                 }
   2637                                             }
   2638                                         }
   2639                                       else
   2640                                         {
   2641                                           if (((word >> 22) & 0x1) == 0)
   2642                                             {
   2643                                               /* 33222222222211111111110000000000
   2644                                                  10987654321098765432109876543210
   2645                                                  xx011001101xxxxxxxxx00xxxxxxxxxx
   2646                                                  stgm.  */
   2647                                               return 963;
   2648                                             }
   2649                                           else
   2650                                             {
   2651                                               /* 33222222222211111111110000000000
   2652                                                  10987654321098765432109876543210
   2653                                                  xx011001111xxxxxxxxx00xxxxxxxxxx
   2654                                                  ldgm.  */
   2655                                               return 962;
   2656                                             }
   2657                                         }
   2658                                     }
   2659                                   else
   2660                                     {
   2661                                       if (((word >> 22) & 0x1) == 0)
   2662                                         {
   2663                                           /* 33222222222211111111110000000000
   2664                                              10987654321098765432109876543210
   2665                                              xx01100110xxxxxxxxxx10xxxxxxxxxx
   2666                                              st2g.  */
   2667                                           return 883;
   2668                                         }
   2669                                       else
   2670                                         {
   2671                                           /* 33222222222211111111110000000000
   2672                                              10987654321098765432109876543210
   2673                                              xx01100111xxxxxxxxxx10xxxxxxxxxx
   2674                                              stz2g.  */
   2675                                           return 884;
   2676                                         }
   2677                                     }
   2678                                 }
   2679                               else
   2680                                 {
   2681                                   if (((word >> 22) & 0x1) == 0)
   2682                                     {
   2683                                       /* 33222222222211111111110000000000
   2684                                          10987654321098765432109876543210
   2685                                          xx01100110xxxxxxxxxxx1xxxxxxxxxx
   2686                                          st2g.  */
   2687                                       return 887;
   2688                                     }
   2689                                   else
   2690                                     {
   2691                                       /* 33222222222211111111110000000000
   2692                                          10987654321098765432109876543210
   2693                                          xx01100111xxxxxxxxxxx1xxxxxxxxxx
   2694                                          stz2g.  */
   2695                                       return 888;
   2696                                     }
   2697                                 }
   2698                             }
   2699                           else
   2700                             {
   2701                               if (((word >> 30) & 0x1) == 0)
   2702                                 {
   2703                                   if (((word >> 31) & 0x1) == 0)
   2704                                     {
   2705                                       /* 33222222222211111111110000000000
   2706                                          10987654321098765432109876543210
   2707                                          001110011xxxxxxxxxxxxxxxxxxxxxxx
   2708                                          ldrsb.  */
   2709                                       return 891;
   2710                                     }
   2711                                   else
   2712                                     {
   2713                                       /* 33222222222211111111110000000000
   2714                                          10987654321098765432109876543210
   2715                                          101110011xxxxxxxxxxxxxxxxxxxxxxx
   2716                                          ldrsw.  */
   2717                                       return 899;
   2718                                     }
   2719                                 }
   2720                               else
   2721                                 {
   2722                                   if (((word >> 31) & 0x1) == 0)
   2723                                     {
   2724                                       /* 33222222222211111111110000000000
   2725                                          10987654321098765432109876543210
   2726                                          011110011xxxxxxxxxxxxxxxxxxxxxxx
   2727                                          ldrsh.  */
   2728                                       return 896;
   2729                                     }
   2730                                   else
   2731                                     {
   2732                                       /* 33222222222211111111110000000000
   2733                                          10987654321098765432109876543210
   2734                                          111110011xxxxxxxxxxxxxxxxxxxxxxx
   2735                                          prfm.  */
   2736                                       return 900;
   2737                                     }
   2738                                 }
   2739                             }
   2740                         }
   2741                     }
   2742                 }
   2743             }
   2744         }
   2745       else
   2746         {
   2747           if (((word >> 24) & 0x1) == 0)
   2748             {
   2749               if (((word >> 27) & 0x1) == 0)
   2750                 {
   2751                   if (((word >> 23) & 0x1) == 0)
   2752                     {
   2753                       if (((word >> 29) & 0x1) == 0)
   2754                         {
   2755                           if (((word >> 30) & 0x1) == 0)
   2756                             {
   2757                               /* 33222222222211111111110000000000
   2758                                  10987654321098765432109876543210
   2759                                  x00x00100xxxxxxxxxxxxxxxxxxxxxxx
   2760                                  and.  */
   2761                               return 991;
   2762                             }
   2763                           else
   2764                             {
   2765                               /* 33222222222211111111110000000000
   2766                                  10987654321098765432109876543210
   2767                                  x10x00100xxxxxxxxxxxxxxxxxxxxxxx
   2768                                  eor.  */
   2769                               return 995;
   2770                             }
   2771                         }
   2772                       else
   2773                         {
   2774                           if (((word >> 30) & 0x1) == 0)
   2775                             {
   2776                               /* 33222222222211111111110000000000
   2777                                  10987654321098765432109876543210
   2778                                  x01x00100xxxxxxxxxxxxxxxxxxxxxxx
   2779                                  orr.  */
   2780                               return 993;
   2781                             }
   2782                           else
   2783                             {
   2784                               /* 33222222222211111111110000000000
   2785                                  10987654321098765432109876543210
   2786                                  x11x00100xxxxxxxxxxxxxxxxxxxxxxx
   2787                                  ands.  */
   2788                               return 996;
   2789                             }
   2790                         }
   2791                     }
   2792                   else
   2793                     {
   2794                       if (((word >> 29) & 0x1) == 0)
   2795                         {
   2796                           if (((word >> 30) & 0x1) == 0)
   2797                             {
   2798                               /* 33222222222211111111110000000000
   2799                                  10987654321098765432109876543210
   2800                                  x00x00101xxxxxxxxxxxxxxxxxxxxxxx
   2801                                  movn.  */
   2802                               return 1182;
   2803                             }
   2804                           else
   2805                             {
   2806                               /* 33222222222211111111110000000000
   2807                                  10987654321098765432109876543210
   2808                                  x10x00101xxxxxxxxxxxxxxxxxxxxxxx
   2809                                  movz.  */
   2810                               return 1184;
   2811                             }
   2812                         }
   2813                       else
   2814                         {
   2815                           /* 33222222222211111111110000000000
   2816                              10987654321098765432109876543210
   2817                              xx1x00101xxxxxxxxxxxxxxxxxxxxxxx
   2818                              movk.  */
   2819                           return 1186;
   2820                         }
   2821                     }
   2822                 }
   2823               else
   2824                 {
   2825                   if (((word >> 21) & 0x1) == 0)
   2826                     {
   2827                       if (((word >> 28) & 0x1) == 0)
   2828                         {
   2829                           if (((word >> 29) & 0x1) == 0)
   2830                             {
   2831                               if (((word >> 30) & 0x1) == 0)
   2832                                 {
   2833                                   /* 33222222222211111111110000000000
   2834                                      10987654321098765432109876543210
   2835                                      x0001010xx0xxxxxxxxxxxxxxxxxxxxx
   2836                                      and.  */
   2837                                   return 998;
   2838                                 }
   2839                               else
   2840                                 {
   2841                                   /* 33222222222211111111110000000000
   2842                                      10987654321098765432109876543210
   2843                                      x1001010xx0xxxxxxxxxxxxxxxxxxxxx
   2844                                      eor.  */
   2845                                   return 1005;
   2846                                 }
   2847                             }
   2848                           else
   2849                             {
   2850                               if (((word >> 30) & 0x1) == 0)
   2851                                 {
   2852                                   /* 33222222222211111111110000000000
   2853                                      10987654321098765432109876543210
   2854                                      x0101010xx0xxxxxxxxxxxxxxxxxxxxx
   2855                                      orr.  */
   2856                                   return 1000;
   2857                                 }
   2858                               else
   2859                                 {
   2860                                   /* 33222222222211111111110000000000
   2861                                      10987654321098765432109876543210
   2862                                      x1101010xx0xxxxxxxxxxxxxxxxxxxxx
   2863                                      ands.  */
   2864                                   return 1007;
   2865                                 }
   2866                             }
   2867                         }
   2868                       else
   2869                         {
   2870                           if (((word >> 10) & 0x1) == 0)
   2871                             {
   2872                               if (((word >> 11) & 0x1) == 0)
   2873                                 {
   2874                                   if (((word >> 22) & 0x1) == 0)
   2875                                     {
   2876                                       if (((word >> 23) & 0x1) == 0)
   2877                                         {
   2878                                           if (((word >> 29) & 0x1) == 0)
   2879                                             {
   2880                                               if (((word >> 30) & 0x1) == 0)
   2881                                                 {
   2882                                                   /* 33222222222211111111110000000000
   2883                                                      10987654321098765432109876543210
   2884                                                      x0011010000xxxxxxxxx00xxxxxxxxxx
   2885                                                      adc.  */
   2886                                                   return 0;
   2887                                                 }
   2888                                               else
   2889                                                 {
   2890                                                   /* 33222222222211111111110000000000
   2891                                                      10987654321098765432109876543210
   2892                                                      x1011010000xxxxxxxxx00xxxxxxxxxx
   2893                                                      sbc.  */
   2894                                                   return 2;
   2895                                                 }
   2896                                             }
   2897                                           else
   2898                                             {
   2899                                               if (((word >> 30) & 0x1) == 0)
   2900                                                 {
   2901                                                   /* 33222222222211111111110000000000
   2902                                                      10987654321098765432109876543210
   2903                                                      x0111010000xxxxxxxxx00xxxxxxxxxx
   2904                                                      adcs.  */
   2905                                                   return 1;
   2906                                                 }
   2907                                               else
   2908                                                 {
   2909                                                   /* 33222222222211111111110000000000
   2910                                                      10987654321098765432109876543210
   2911                                                      x1111010000xxxxxxxxx00xxxxxxxxxx
   2912                                                      sbcs.  */
   2913                                                   return 4;
   2914                                                 }
   2915                                             }
   2916                                         }
   2917                                       else
   2918                                         {
   2919                                           if (((word >> 30) & 0x1) == 0)
   2920                                             {
   2921                                               /* 33222222222211111111110000000000
   2922                                                  10987654321098765432109876543210
   2923                                                  x0x11010100xxxxxxxxx00xxxxxxxxxx
   2924                                                  csel.  */
   2925                                               return 662;
   2926                                             }
   2927                                           else
   2928                                             {
   2929                                               /* 33222222222211111111110000000000
   2930                                                  10987654321098765432109876543210
   2931                                                  x1x11010100xxxxxxxxx00xxxxxxxxxx
   2932                                                  csinv.  */
   2933                                               return 666;
   2934                                             }
   2935                                         }
   2936                                     }
   2937                                   else
   2938                                     {
   2939                                       if (((word >> 23) & 0x1) == 0)
   2940                                         {
   2941                                           if (((word >> 30) & 0x1) == 0)
   2942                                             {
   2943                                               /* 33222222222211111111110000000000
   2944                                                  10987654321098765432109876543210
   2945                                                  x0x11010010xxxxxxxxx00xxxxxxxxxx
   2946                                                  ccmn.  */
   2947                                               return 660;
   2948                                             }
   2949                                           else
   2950                                             {
   2951                                               /* 33222222222211111111110000000000
   2952                                                  10987654321098765432109876543210
   2953                                                  x1x11010010xxxxxxxxx00xxxxxxxxxx
   2954                                                  ccmp.  */
   2955                                               return 661;
   2956                                             }
   2957                                         }
   2958                                       else
   2959                                         {
   2960                                           if (((word >> 12) & 0x1) == 0)
   2961                                             {
   2962                                               if (((word >> 13) & 0x1) == 0)
   2963                                                 {
   2964                                                   if (((word >> 14) & 0x1) == 0)
   2965                                                     {
   2966                                                       if (((word >> 29) & 0x1) == 0)
   2967                                                         {
   2968                                                           if (((word >> 30) & 0x1) == 0)
   2969                                                             {
   2970                                                               /* 33222222222211111111110000000000
   2971                                                                  10987654321098765432109876543210
   2972                                                                  x0011010110xxxxxx00000xxxxxxxxxx
   2973                                                                  subp.  */
   2974                                                               return 721;
   2975                                                             }
   2976                                                           else
   2977                                                             {
   2978                                                               if (((word >> 16) & 0x1) == 0)
   2979                                                                 {
   2980                                                                   /* 33222222222211111111110000000000
   2981                                                                      10987654321098765432109876543210
   2982                                                                      x1011010110xxxx0x00000xxxxxxxxxx
   2983                                                                      rbit.  */
   2984                                                                   return 685;
   2985                                                                 }
   2986                                                               else
   2987                                                                 {
   2988                                                                   /* 33222222222211111111110000000000
   2989                                                                      10987654321098765432109876543210
   2990                                                                      x1011010110xxxx1x00000xxxxxxxxxx
   2991                                                                      pacia.  */
   2992                                                                   return 693;
   2993                                                                 }
   2994                                                             }
   2995                                                         }
   2996                                                       else
   2997                                                         {
   2998                                                           /* 33222222222211111111110000000000
   2999                                                              10987654321098765432109876543210
   3000                                                              xx111010110xxxxxx00000xxxxxxxxxx
   3001                                                              subps.  */
   3002                                                           return 722;
   3003                                                         }
   3004                                                     }
   3005                                                   else
   3006                                                     {
   3007                                                       if (((word >> 30) & 0x1) == 0)
   3008                                                         {
   3009                                                           /* 33222222222211111111110000000000
   3010                                                              10987654321098765432109876543210
   3011                                                              x0x11010110xxxxxx10000xxxxxxxxxx
   3012                                                              crc32b.  */
   3013                                                           return 727;
   3014                                                         }
   3015                                                       else
   3016                                                         {
   3017                                                           /* 33222222222211111111110000000000
   3018                                                              10987654321098765432109876543210
   3019                                                              x1x11010110xxxxxx10000xxxxxxxxxx
   3020                                                              xpaci.  */
   3021                                                           return 709;
   3022                                                         }
   3023                                                     }
   3024                                                 }
   3025                                               else
   3026                                                 {
   3027                                                   if (((word >> 30) & 0x1) == 0)
   3028                                                     {
   3029                                                       /* 33222222222211111111110000000000
   3030                                                          10987654321098765432109876543210
   3031                                                          x0x11010110xxxxxxx1000xxxxxxxxxx
   3032                                                          lslv.  */
   3033                                                       return 713;
   3034                                                     }
   3035                                                   else
   3036                                                     {
   3037                                                       /* 33222222222211111111110000000000
   3038                                                          10987654321098765432109876543210
   3039                                                          x1x11010110xxxxxxx1000xxxxxxxxxx
   3040                                                          paciza.  */
   3041                                                       return 701;
   3042                                                     }
   3043                                                 }
   3044                                             }
   3045                                           else
   3046                                             {
   3047                                               if (((word >> 13) & 0x1) == 0)
   3048                                                 {
   3049                                                   if (((word >> 14) & 0x1) == 0)
   3050                                                     {
   3051                                                       if (((word >> 30) & 0x1) == 0)
   3052                                                         {
   3053                                                           /* 33222222222211111111110000000000
   3054                                                              10987654321098765432109876543210
   3055                                                              x0x11010110xxxxxx00100xxxxxxxxxx
   3056                                                              irg.  */
   3057                                                           return 724;
   3058                                                         }
   3059                                                       else
   3060                                                         {
   3061                                                           if (((word >> 16) & 0x1) == 0)
   3062                                                             {
   3063                                                               /* 33222222222211111111110000000000
   3064                                                                  10987654321098765432109876543210
   3065                                                                  x1x11010110xxxx0x00100xxxxxxxxxx
   3066                                                                  clz.  */
   3067                                                               return 690;
   3068                                                             }
   3069                                                           else
   3070                                                             {
   3071                                                               /* 33222222222211111111110000000000
   3072                                                                  10987654321098765432109876543210
   3073                                                                  x1x11010110xxxx1x00100xxxxxxxxxx
   3074                                                                  autia.  */
   3075                                                               return 697;
   3076                                                             }
   3077                                                         }
   3078                                                     }
   3079                                                   else
   3080                                                     {
   3081                                                       /* 33222222222211111111110000000000
   3082                                                          10987654321098765432109876543210
   3083                                                          xxx11010110xxxxxx10100xxxxxxxxxx
   3084                                                          crc32cb.  */
   3085                                                       return 731;
   3086                                                     }
   3087                                                 }
   3088                                               else
   3089                                                 {
   3090                                                   if (((word >> 30) & 0x1) == 0)
   3091                                                     {
   3092                                                       /* 33222222222211111111110000000000
   3093                                                          10987654321098765432109876543210
   3094                                                          x0x11010110xxxxxxx1100xxxxxxxxxx
   3095                                                          pacga.  */
   3096                                                       return 726;
   3097                                                     }
   3098                                                   else
   3099                                                     {
   3100                                                       /* 33222222222211111111110000000000
   3101                                                          10987654321098765432109876543210
   3102                                                          x1x11010110xxxxxxx1100xxxxxxxxxx
   3103                                                          autiza.  */
   3104                                                       return 705;
   3105                                                     }
   3106                                                 }
   3107                                             }
   3108                                         }
   3109                                     }
   3110                                 }
   3111                               else
   3112                                 {
   3113                                   if (((word >> 22) & 0x1) == 0)
   3114                                     {
   3115                                       if (((word >> 14) & 0x1) == 0)
   3116                                         {
   3117                                           /* 33222222222211111111110000000000
   3118                                              10987654321098765432109876543210
   3119                                              xxx11010x00xxxxxx0xx10xxxxxxxxxx
   3120                                              setf8.  */
   3121                                           return 2379;
   3122                                         }
   3123                                       else
   3124                                         {
   3125                                           /* 33222222222211111111110000000000
   3126                                              10987654321098765432109876543210
   3127                                              xxx11010x00xxxxxx1xx10xxxxxxxxxx
   3128                                              setf16.  */
   3129                                           return 2380;
   3130                                         }
   3131                                     }
   3132                                   else
   3133                                     {
   3134                                       if (((word >> 23) & 0x1) == 0)
   3135                                         {
   3136                                           if (((word >> 30) & 0x1) == 0)
   3137                                             {
   3138                                               /* 33222222222211111111110000000000
   3139                                                  10987654321098765432109876543210
   3140                                                  x0x11010010xxxxxxxxx10xxxxxxxxxx
   3141                                                  ccmn.  */
   3142                                               return 658;
   3143                                             }
   3144                                           else
   3145                                             {
   3146                                               /* 33222222222211111111110000000000
   3147                                                  10987654321098765432109876543210
   3148                                                  x1x11010010xxxxxxxxx10xxxxxxxxxx
   3149                                                  ccmp.  */
   3150                                               return 659;
   3151                                             }
   3152                                         }
   3153                                       else
   3154                                         {
   3155                                           if (((word >> 12) & 0x1) == 0)
   3156                                             {
   3157                                               if (((word >> 13) & 0x1) == 0)
   3158                                                 {
   3159                                                   if (((word >> 14) & 0x1) == 0)
   3160                                                     {
   3161                                                       if (((word >> 30) & 0x1) == 0)
   3162                                                         {
   3163                                                           /* 33222222222211111111110000000000
   3164                                                              10987654321098765432109876543210
   3165                                                              x0x11010110xxxxxx00010xxxxxxxxxx
   3166                                                              udiv.  */
   3167                                                           return 711;
   3168                                                         }
   3169                                                       else
   3170                                                         {
   3171                                                           if (((word >> 16) & 0x1) == 0)
   3172                                                             {
   3173                                                               if (((word >> 31) & 0x1) == 0)
   3174                                                                 {
   3175                                                                   /* 33222222222211111111110000000000
   3176                                                                      10987654321098765432109876543210
   3177                                                                      01x11010110xxxx0x00010xxxxxxxxxx
   3178                                                                      rev.  */
   3179                                                                   return 687;
   3180                                                                 }
   3181                                                               else
   3182                                                                 {
   3183                                                                   /* 33222222222211111111110000000000
   3184                                                                      10987654321098765432109876543210
   3185                                                                      11x11010110xxxx0x00010xxxxxxxxxx
   3186                                                                      rev32.  */
   3187                                                                   return 692;
   3188                                                                 }
   3189                                                             }
   3190                                                           else
   3191                                                             {
   3192                                                               /* 33222222222211111111110000000000
   3193                                                                  10987654321098765432109876543210
   3194                                                                  x1x11010110xxxx1x00010xxxxxxxxxx
   3195                                                                  pacda.  */
   3196                                                               return 695;
   3197                                                             }
   3198                                                         }
   3199                                                     }
   3200                                                   else
   3201                                                     {
   3202                                                       /* 33222222222211111111110000000000
   3203                                                          10987654321098765432109876543210
   3204                                                          xxx11010110xxxxxx10010xxxxxxxxxx
   3205                                                          crc32w.  */
   3206                                                       return 729;
   3207                                                     }
   3208                                                 }
   3209                                               else
   3210                                                 {
   3211                                                   if (((word >> 30) & 0x1) == 0)
   3212                                                     {
   3213                                                       /* 33222222222211111111110000000000
   3214                                                          10987654321098765432109876543210
   3215                                                          x0x11010110xxxxxxx1010xxxxxxxxxx
   3216                                                          asrv.  */
   3217                                                       return 717;
   3218                                                     }
   3219                                                   else
   3220                                                     {
   3221                                                       /* 33222222222211111111110000000000
   3222                                                          10987654321098765432109876543210
   3223                                                          x1x11010110xxxxxxx1010xxxxxxxxxx
   3224                                                          pacdza.  */
   3225                                                       return 703;
   3226                                                     }
   3227                                                 }
   3228                                             }
   3229                                           else
   3230                                             {
   3231                                               if (((word >> 13) & 0x1) == 0)
   3232                                                 {
   3233                                                   if (((word >> 14) & 0x1) == 0)
   3234                                                     {
   3235                                                       /* 33222222222211111111110000000000
   3236                                                          10987654321098765432109876543210
   3237                                                          xxx11010110xxxxxx00110xxxxxxxxxx
   3238                                                          autda.  */
   3239                                                       return 699;
   3240                                                     }
   3241                                                   else
   3242                                                     {
   3243                                                       /* 33222222222211111111110000000000
   3244                                                          10987654321098765432109876543210
   3245                                                          xxx11010110xxxxxx10110xxxxxxxxxx
   3246                                                          crc32cw.  */
   3247                                                       return 733;
   3248                                                     }
   3249                                                 }
   3250                                               else
   3251                                                 {
   3252                                                   /* 33222222222211111111110000000000
   3253                                                      10987654321098765432109876543210
   3254                                                      xxx11010110xxxxxxx1110xxxxxxxxxx
   3255                                                      autdza.  */
   3256                                                   return 707;
   3257                                                 }
   3258                                             }
   3259                                         }
   3260                                     }
   3261                                 }
   3262                             }
   3263                           else
   3264                             {
   3265                               if (((word >> 11) & 0x1) == 0)
   3266                                 {
   3267                                   if (((word >> 22) & 0x1) == 0)
   3268                                     {
   3269                                       if (((word >> 23) & 0x1) == 0)
   3270                                         {
   3271                                           /* 33222222222211111111110000000000
   3272                                              10987654321098765432109876543210
   3273                                              xxx11010000xxxxxxxxx01xxxxxxxxxx
   3274                                              rmif.  */
   3275                                           return 2378;
   3276                                         }
   3277                                       else
   3278                                         {
   3279                                           if (((word >> 30) & 0x1) == 0)
   3280                                             {
   3281                                               /* 33222222222211111111110000000000
   3282                                                  10987654321098765432109876543210
   3283                                                  x0x11010100xxxxxxxxx01xxxxxxxxxx
   3284                                                  csinc.  */
   3285                                               return 663;
   3286                                             }
   3287                                           else
   3288                                             {
   3289                                               /* 33222222222211111111110000000000
   3290                                                  10987654321098765432109876543210
   3291                                                  x1x11010100xxxxxxxxx01xxxxxxxxxx
   3292                                                  csneg.  */
   3293                                               return 669;
   3294                                             }
   3295                                         }
   3296                                     }
   3297                                   else
   3298                                     {
   3299                                       if (((word >> 12) & 0x1) == 0)
   3300                                         {
   3301                                           if (((word >> 13) & 0x1) == 0)
   3302                                             {
   3303                                               if (((word >> 14) & 0x1) == 0)
   3304                                                 {
   3305                                                   if (((word >> 16) & 0x1) == 0)
   3306                                                     {
   3307                                                       /* 33222222222211111111110000000000
   3308                                                          10987654321098765432109876543210
   3309                                                          xxx11010x10xxxx0x00001xxxxxxxxxx
   3310                                                          rev16.  */
   3311                                                       return 686;
   3312                                                     }
   3313                                                   else
   3314                                                     {
   3315                                                       /* 33222222222211111111110000000000
   3316                                                          10987654321098765432109876543210
   3317                                                          xxx11010x10xxxx1x00001xxxxxxxxxx
   3318                                                          pacib.  */
   3319                                                       return 694;
   3320                                                     }
   3321                                                 }
   3322                                               else
   3323                                                 {
   3324                                                   if (((word >> 30) & 0x1) == 0)
   3325                                                     {
   3326                                                       /* 33222222222211111111110000000000
   3327                                                          10987654321098765432109876543210
   3328                                                          x0x11010x10xxxxxx10001xxxxxxxxxx
   3329                                                          crc32h.  */
   3330                                                       return 728;
   3331                                                     }
   3332                                                   else
   3333                                                     {
   3334                                                       /* 33222222222211111111110000000000
   3335                                                          10987654321098765432109876543210
   3336                                                          x1x11010x10xxxxxx10001xxxxxxxxxx
   3337                                                          xpacd.  */
   3338                                                       return 710;
   3339                                                     }
   3340                                                 }
   3341                                             }
   3342                                           else
   3343                                             {
   3344                                               if (((word >> 30) & 0x1) == 0)
   3345                                                 {
   3346                                                   /* 33222222222211111111110000000000
   3347                                                      10987654321098765432109876543210
   3348                                                      x0x11010x10xxxxxxx1001xxxxxxxxxx
   3349                                                      lsrv.  */
   3350                                                   return 715;
   3351                                                 }
   3352                                               else
   3353                                                 {
   3354                                                   /* 33222222222211111111110000000000
   3355                                                      10987654321098765432109876543210
   3356                                                      x1x11010x10xxxxxxx1001xxxxxxxxxx
   3357                                                      pacizb.  */
   3358                                                   return 702;
   3359                                                 }
   3360                                             }
   3361                                         }
   3362                                       else
   3363                                         {
   3364                                           if (((word >> 13) & 0x1) == 0)
   3365                                             {
   3366                                               if (((word >> 14) & 0x1) == 0)
   3367                                                 {
   3368                                                   if (((word >> 30) & 0x1) == 0)
   3369                                                     {
   3370                                                       /* 33222222222211111111110000000000
   3371                                                          10987654321098765432109876543210
   3372                                                          x0x11010x10xxxxxx00101xxxxxxxxxx
   3373                                                          gmi.  */
   3374                                                       return 725;
   3375                                                     }
   3376                                                   else
   3377                                                     {
   3378                                                       if (((word >> 16) & 0x1) == 0)
   3379                                                         {
   3380                                                           /* 33222222222211111111110000000000
   3381                                                              10987654321098765432109876543210
   3382                                                              x1x11010x10xxxx0x00101xxxxxxxxxx
   3383                                                              cls.  */
   3384                                                           return 691;
   3385                                                         }
   3386                                                       else
   3387                                                         {
   3388                                                           /* 33222222222211111111110000000000
   3389                                                              10987654321098765432109876543210
   3390                                                              x1x11010x10xxxx1x00101xxxxxxxxxx
   3391                                                              autib.  */
   3392                                                           return 698;
   3393                                                         }
   3394                                                     }
   3395                                                 }
   3396                                               else
   3397                                                 {
   3398                                                   /* 33222222222211111111110000000000
   3399                                                      10987654321098765432109876543210
   3400                                                      xxx11010x10xxxxxx10101xxxxxxxxxx
   3401                                                      crc32ch.  */
   3402                                                   return 732;
   3403                                                 }
   3404                                             }
   3405                                           else
   3406                                             {
   3407                                               /* 33222222222211111111110000000000
   3408                                                  10987654321098765432109876543210
   3409                                                  xxx11010x10xxxxxxx1101xxxxxxxxxx
   3410                                                  autizb.  */
   3411                                               return 706;
   3412                                             }
   3413                                         }
   3414                                     }
   3415                                 }
   3416                               else
   3417                                 {
   3418                                   if (((word >> 12) & 0x1) == 0)
   3419                                     {
   3420                                       if (((word >> 13) & 0x1) == 0)
   3421                                         {
   3422                                           if (((word >> 14) & 0x1) == 0)
   3423                                             {
   3424                                               if (((word >> 30) & 0x1) == 0)
   3425                                                 {
   3426                                                   /* 33222222222211111111110000000000
   3427                                                      10987654321098765432109876543210
   3428                                                      x0x11010xx0xxxxxx00011xxxxxxxxxx
   3429                                                      sdiv.  */
   3430                                                   return 712;
   3431                                                 }
   3432                                               else
   3433                                                 {
   3434                                                   if (((word >> 16) & 0x1) == 0)
   3435                                                     {
   3436                                                       /* 33222222222211111111110000000000
   3437                                                          10987654321098765432109876543210
   3438                                                          x1x11010xx0xxxx0x00011xxxxxxxxxx
   3439                                                          rev.  */
   3440                                                       return 688;
   3441                                                     }
   3442                                                   else
   3443                                                     {
   3444                                                       /* 33222222222211111111110000000000
   3445                                                          10987654321098765432109876543210
   3446                                                          x1x11010xx0xxxx1x00011xxxxxxxxxx
   3447                                                          pacdb.  */
   3448                                                       return 696;
   3449                                                     }
   3450                                                 }
   3451                                             }
   3452                                           else
   3453                                             {
   3454                                               /* 33222222222211111111110000000000
   3455                                                  10987654321098765432109876543210
   3456                                                  xxx11010xx0xxxxxx10011xxxxxxxxxx
   3457                                                  crc32x.  */
   3458                                               return 730;
   3459                                             }
   3460                                         }
   3461                                       else
   3462                                         {
   3463                                           if (((word >> 30) & 0x1) == 0)
   3464                                             {
   3465                                               /* 33222222222211111111110000000000
   3466                                                  10987654321098765432109876543210
   3467                                                  x0x11010xx0xxxxxxx1011xxxxxxxxxx
   3468                                                  rorv.  */
   3469                                               return 719;
   3470                                             }
   3471                                           else
   3472                                             {
   3473                                               /* 33222222222211111111110000000000
   3474                                                  10987654321098765432109876543210
   3475                                                  x1x11010xx0xxxxxxx1011xxxxxxxxxx
   3476                                                  pacdzb.  */
   3477                                               return 704;
   3478                                             }
   3479                                         }
   3480                                     }
   3481                                   else
   3482                                     {
   3483                                       if (((word >> 13) & 0x1) == 0)
   3484                                         {
   3485                                           if (((word >> 14) & 0x1) == 0)
   3486                                             {
   3487                                               /* 33222222222211111111110000000000
   3488                                                  10987654321098765432109876543210
   3489                                                  xxx11010xx0xxxxxx00111xxxxxxxxxx
   3490                                                  autdb.  */
   3491                                               return 700;
   3492                                             }
   3493                                           else
   3494                                             {
   3495                                               /* 33222222222211111111110000000000
   3496                                                  10987654321098765432109876543210
   3497                                                  xxx11010xx0xxxxxx10111xxxxxxxxxx
   3498                                                  crc32cx.  */
   3499                                               return 734;
   3500                                             }
   3501                                         }
   3502                                       else
   3503                                         {
   3504                                           /* 33222222222211111111110000000000
   3505                                              10987654321098765432109876543210
   3506                                              xxx11010xx0xxxxxxx1111xxxxxxxxxx
   3507                                              autdzb.  */
   3508                                           return 708;
   3509                                         }
   3510                                     }
   3511                                 }
   3512                             }
   3513                         }
   3514                     }
   3515                   else
   3516                     {
   3517                       if (((word >> 29) & 0x1) == 0)
   3518                         {
   3519                           if (((word >> 30) & 0x1) == 0)
   3520                             {
   3521                               /* 33222222222211111111110000000000
   3522                                  10987654321098765432109876543210
   3523                                  x00x1010xx1xxxxxxxxxxxxxxxxxxxxx
   3524                                  bic.  */
   3525                               return 999;
   3526                             }
   3527                           else
   3528                             {
   3529                               /* 33222222222211111111110000000000
   3530                                  10987654321098765432109876543210
   3531                                  x10x1010xx1xxxxxxxxxxxxxxxxxxxxx
   3532                                  eon.  */
   3533                               return 1006;
   3534                             }
   3535                         }
   3536                       else
   3537                         {
   3538                           if (((word >> 30) & 0x1) == 0)
   3539                             {
   3540                               /* 33222222222211111111110000000000
   3541                                  10987654321098765432109876543210
   3542                                  x01x1010xx1xxxxxxxxxxxxxxxxxxxxx
   3543                                  orn.  */
   3544                               return 1003;
   3545                             }
   3546                           else
   3547                             {
   3548                               /* 33222222222211111111110000000000
   3549                                  10987654321098765432109876543210
   3550                                  x11x1010xx1xxxxxxxxxxxxxxxxxxxxx
   3551                                  bics.  */
   3552                               return 1009;
   3553                             }
   3554                         }
   3555                     }
   3556                 }
   3557             }
   3558           else
   3559             {
   3560               if (((word >> 27) & 0x1) == 0)
   3561                 {
   3562                   if (((word >> 23) & 0x1) == 0)
   3563                     {
   3564                       if (((word >> 29) & 0x1) == 0)
   3565                         {
   3566                           if (((word >> 30) & 0x1) == 0)
   3567                             {
   3568                               /* 33222222222211111111110000000000
   3569                                  10987654321098765432109876543210
   3570                                  x00x00110xxxxxxxxxxxxxxxxxxxxxxx
   3571                                  sbfm.  */
   3572                               return 618;
   3573                             }
   3574                           else
   3575                             {
   3576                               /* 33222222222211111111110000000000
   3577                                  10987654321098765432109876543210
   3578                                  x10x00110xxxxxxxxxxxxxxxxxxxxxxx
   3579                                  ubfm.  */
   3580                               return 629;
   3581                             }
   3582                         }
   3583                       else
   3584                         {
   3585                           /* 33222222222211111111110000000000
   3586                              10987654321098765432109876543210
   3587                              xx1x00110xxxxxxxxxxxxxxxxxxxxxxx
   3588                              bfm.  */
   3589                           return 625;
   3590                         }
   3591                     }
   3592                   else
   3593                     {
   3594                       /* 33222222222211111111110000000000
   3595                          10987654321098765432109876543210
   3596                          xxxx00111xxxxxxxxxxxxxxxxxxxxxxx
   3597                          extr.  */
   3598                       return 758;
   3599                     }
   3600                 }
   3601               else
   3602                 {
   3603                   if (((word >> 21) & 0x1) == 0)
   3604                     {
   3605                       if (((word >> 28) & 0x1) == 0)
   3606                         {
   3607                           if (((word >> 29) & 0x1) == 0)
   3608                             {
   3609                               if (((word >> 30) & 0x1) == 0)
   3610                                 {
   3611                                   /* 33222222222211111111110000000000
   3612                                      10987654321098765432109876543210
   3613                                      x0001011xx0xxxxxxxxxxxxxxxxxxxxx
   3614                                      add.  */
   3615                                   return 21;
   3616                                 }
   3617                               else
   3618                                 {
   3619                                   /* 33222222222211111111110000000000
   3620                                      10987654321098765432109876543210
   3621                                      x1001011xx0xxxxxxxxxxxxxxxxxxxxx
   3622                                      sub.  */
   3623                                   return 24;
   3624                                 }
   3625                             }
   3626                           else
   3627                             {
   3628                               if (((word >> 30) & 0x1) == 0)
   3629                                 {
   3630                                   /* 33222222222211111111110000000000
   3631                                      10987654321098765432109876543210
   3632                                      x0101011xx0xxxxxxxxxxxxxxxxxxxxx
   3633                                      adds.  */
   3634                                   return 22;
   3635                                 }
   3636                               else
   3637                                 {
   3638                                   /* 33222222222211111111110000000000
   3639                                      10987654321098765432109876543210
   3640                                      x1101011xx0xxxxxxxxxxxxxxxxxxxxx
   3641                                      subs.  */
   3642                                   return 26;
   3643                                 }
   3644                             }
   3645                         }
   3646                       else
   3647                         {
   3648                           if (((word >> 15) & 0x1) == 0)
   3649                             {
   3650                               if (((word >> 22) & 0x1) == 0)
   3651                                 {
   3652                                   /* 33222222222211111111110000000000
   3653                                      10987654321098765432109876543210
   3654                                      xxx11011x00xxxxx0xxxxxxxxxxxxxxx
   3655                                      madd.  */
   3656                                   return 735;
   3657                                 }
   3658                               else
   3659                                 {
   3660                                   if (((word >> 23) & 0x1) == 0)
   3661                                     {
   3662                                       /* 33222222222211111111110000000000
   3663                                          10987654321098765432109876543210
   3664                                          xxx11011010xxxxx0xxxxxxxxxxxxxxx
   3665                                          smulh.  */
   3666                                       return 743;
   3667                                     }
   3668                                   else
   3669                                     {
   3670                                       /* 33222222222211111111110000000000
   3671                                          10987654321098765432109876543210
   3672                                          xxx11011110xxxxx0xxxxxxxxxxxxxxx
   3673                                          umulh.  */
   3674                                       return 748;
   3675                                     }
   3676                                 }
   3677                             }
   3678                           else
   3679                             {
   3680                               /* 33222222222211111111110000000000
   3681                                  10987654321098765432109876543210
   3682                                  xxx11011xx0xxxxx1xxxxxxxxxxxxxxx
   3683                                  msub.  */
   3684                               return 737;
   3685                             }
   3686                         }
   3687                     }
   3688                   else
   3689                     {
   3690                       if (((word >> 23) & 0x1) == 0)
   3691                         {
   3692                           if (((word >> 28) & 0x1) == 0)
   3693                             {
   3694                               if (((word >> 29) & 0x1) == 0)
   3695                                 {
   3696                                   if (((word >> 30) & 0x1) == 0)
   3697                                     {
   3698                                       /* 33222222222211111111110000000000
   3699                                          10987654321098765432109876543210
   3700                                          x00010110x1xxxxxxxxxxxxxxxxxxxxx
   3701                                          add.  */
   3702                                       return 6;
   3703                                     }
   3704                                   else
   3705                                     {
   3706                                       /* 33222222222211111111110000000000
   3707                                          10987654321098765432109876543210
   3708                                          x10010110x1xxxxxxxxxxxxxxxxxxxxx
   3709                                          sub.  */
   3710                                       return 9;
   3711                                     }
   3712                                 }
   3713                               else
   3714                                 {
   3715                                   if (((word >> 30) & 0x1) == 0)
   3716                                     {
   3717                                       /* 33222222222211111111110000000000
   3718                                          10987654321098765432109876543210
   3719                                          x01010110x1xxxxxxxxxxxxxxxxxxxxx
   3720                                          adds.  */
   3721                                       return 7;
   3722                                     }
   3723                                   else
   3724                                     {
   3725                                       /* 33222222222211111111110000000000
   3726                                          10987654321098765432109876543210
   3727                                          x11010110x1xxxxxxxxxxxxxxxxxxxxx
   3728                                          subs.  */
   3729                                       return 10;
   3730                                     }
   3731                                 }
   3732                             }
   3733                           else
   3734                             {
   3735                               if (((word >> 15) & 0x1) == 0)
   3736                                 {
   3737                                   /* 33222222222211111111110000000000
   3738                                      10987654321098765432109876543210
   3739                                      xxx110110x1xxxxx0xxxxxxxxxxxxxxx
   3740                                      smaddl.  */
   3741                                   return 739;
   3742                                 }
   3743                               else
   3744                                 {
   3745                                   /* 33222222222211111111110000000000
   3746                                      10987654321098765432109876543210
   3747                                      xxx110110x1xxxxx1xxxxxxxxxxxxxxx
   3748                                      smsubl.  */
   3749                                   return 741;
   3750                                 }
   3751                             }
   3752                         }
   3753                       else
   3754                         {
   3755                           if (((word >> 15) & 0x1) == 0)
   3756                             {
   3757                               /* 33222222222211111111110000000000
   3758                                  10987654321098765432109876543210
   3759                                  xxxx10111x1xxxxx0xxxxxxxxxxxxxxx
   3760                                  umaddl.  */
   3761                               return 744;
   3762                             }
   3763                           else
   3764                             {
   3765                               /* 33222222222211111111110000000000
   3766                                  10987654321098765432109876543210
   3767                                  xxxx10111x1xxxxx1xxxxxxxxxxxxxxx
   3768                                  umsubl.  */
   3769                               return 746;
   3770                             }
   3771                         }
   3772                     }
   3773                 }
   3774             }
   3775         }
   3776     }
   3777   else
   3778     {
   3779       if (((word >> 27) & 0x1) == 0)
   3780         {
   3781           if (((word >> 28) & 0x1) == 0)
   3782             {
   3783               if (((word >> 24) & 0x1) == 0)
   3784                 {
   3785                   if (((word >> 29) & 0x1) == 0)
   3786                     {
   3787                       if (((word >> 13) & 0x1) == 0)
   3788                         {
   3789                           if (((word >> 14) & 0x1) == 0)
   3790                             {
   3791                               if (((word >> 15) & 0x1) == 0)
   3792                                 {
   3793                                   if (((word >> 21) & 0x1) == 0)
   3794                                     {
   3795                                       if (((word >> 30) & 0x1) == 0)
   3796                                         {
   3797                                           if (((word >> 31) & 0x1) == 0)
   3798                                             {
   3799                                               if (((word >> 16) & 0x1) == 0)
   3800                                                 {
   3801                                                   if (((word >> 17) & 0x1) == 0)
   3802                                                     {
   3803                                                       if (((word >> 18) & 0x1) == 0)
   3804                                                         {
   3805                                                           if (((word >> 19) & 0x1) == 0)
   3806                                                             {
   3807                                                               if (((word >> 20) & 0x1) == 0)
   3808                                                                 {
   3809                                                                   /* 33222222222211111111110000000000
   3810                                                                      10987654321098765432109876543210
   3811                                                                      000001x0xx000000000xxxxxxxxxxxxx
   3812                                                                      add.  */
   3813                                                                   return 1280;
   3814                                                                 }
   3815                                                               else
   3816                                                                 {
   3817                                                                   /* 33222222222211111111110000000000
   3818                                                                      10987654321098765432109876543210
   3819                                                                      000001x0xx010000000xxxxxxxxxxxxx
   3820                                                                      mul.  */
   3821                                                                   return 1749;
   3822                                                                 }
   3823                                                             }
   3824                                                           else
   3825                                                             {
   3826                                                               if (((word >> 20) & 0x1) == 0)
   3827                                                                 {
   3828                                                                   /* 33222222222211111111110000000000
   3829                                                                      10987654321098765432109876543210
   3830                                                                      000001x0xx001000000xxxxxxxxxxxxx
   3831                                                                      smax.  */
   3832                                                                   return 1828;
   3833                                                                 }
   3834                                                               else
   3835                                                                 {
   3836                                                                   /* 33222222222211111111110000000000
   3837                                                                      10987654321098765432109876543210
   3838                                                                      000001x0xx011000000xxxxxxxxxxxxx
   3839                                                                      orr.  */
   3840                                                                   return 1760;
   3841                                                                 }
   3842                                                             }
   3843                                                         }
   3844                                                       else
   3845                                                         {
   3846                                                           if (((word >> 19) & 0x1) == 0)
   3847                                                             {
   3848                                                               /* 33222222222211111111110000000000
   3849                                                                  10987654321098765432109876543210
   3850                                                                  000001x0xx0x0100000xxxxxxxxxxxxx
   3851                                                                  sdiv.  */
   3852                                                               return 1819;
   3853                                                             }
   3854                                                           else
   3855                                                             {
   3856                                                               /* 33222222222211111111110000000000
   3857                                                                  10987654321098765432109876543210
   3858                                                                  000001x0xx0x1100000xxxxxxxxxxxxx
   3859                                                                  sabd.  */
   3860                                                               return 1810;
   3861                                                             }
   3862                                                         }
   3863                                                     }
   3864                                                   else
   3865                                                     {
   3866                                                       if (((word >> 18) & 0x1) == 0)
   3867                                                         {
   3868                                                           if (((word >> 19) & 0x1) == 0)
   3869                                                             {
   3870                                                               /* 33222222222211111111110000000000
   3871                                                                  10987654321098765432109876543210
   3872                                                                  000001x0xx0x0010000xxxxxxxxxxxxx
   3873                                                                  smulh.  */
   3874                                                               return 1833;
   3875                                                             }
   3876                                                           else
   3877                                                             {
   3878                                                               if (((word >> 20) & 0x1) == 0)
   3879                                                                 {
   3880                                                                   /* 33222222222211111111110000000000
   3881                                                                      10987654321098765432109876543210
   3882                                                                      000001x0xx001010000xxxxxxxxxxxxx
   3883                                                                      smin.  */
   3884                                                                   return 1831;
   3885                                                                 }
   3886                                                               else
   3887                                                                 {
   3888                                                                   /* 33222222222211111111110000000000
   3889                                                                      10987654321098765432109876543210
   3890                                                                      000001x0xx011010000xxxxxxxxxxxxx
   3891                                                                      and.  */
   3892                                                                   return 1288;
   3893                                                                 }
   3894                                                             }
   3895                                                         }
   3896                                                       else
   3897                                                         {
   3898                                                           /* 33222222222211111111110000000000
   3899                                                              10987654321098765432109876543210
   3900                                                              000001x0xx0xx110000xxxxxxxxxxxxx
   3901                                                              sdivr.  */
   3902                                                           return 1820;
   3903                                                         }
   3904                                                     }
   3905                                                 }
   3906                                               else
   3907                                                 {
   3908                                                   if (((word >> 17) & 0x1) == 0)
   3909                                                     {
   3910                                                       if (((word >> 18) & 0x1) == 0)
   3911                                                         {
   3912                                                           if (((word >> 19) & 0x1) == 0)
   3913                                                             {
   3914                                                               /* 33222222222211111111110000000000
   3915                                                                  10987654321098765432109876543210
   3916                                                                  000001x0xx0x0001000xxxxxxxxxxxxx
   3917                                                                  sub.  */
   3918                                                               return 1949;
   3919                                                             }
   3920                                                           else
   3921                                                             {
   3922                                                               if (((word >> 20) & 0x1) == 0)
   3923                                                                 {
   3924                                                                   /* 33222222222211111111110000000000
   3925                                                                      10987654321098765432109876543210
   3926                                                                      000001x0xx001001000xxxxxxxxxxxxx
   3927                                                                      umax.  */
   3928                                                                   return 1977;
   3929                                                                 }
   3930                                                               else
   3931                                                                 {
   3932                                                                   /* 33222222222211111111110000000000
   3933                                                                      10987654321098765432109876543210
   3934                                                                      000001x0xx011001000xxxxxxxxxxxxx
   3935                                                                      eor.  */
   3936                                                                   return 1375;
   3937                                                                 }
   3938                                                             }
   3939                                                         }
   3940                                                       else
   3941                                                         {
   3942                                                           if (((word >> 19) & 0x1) == 0)
   3943                                                             {
   3944                                                               /* 33222222222211111111110000000000
   3945                                                                  10987654321098765432109876543210
   3946                                                                  000001x0xx0x0101000xxxxxxxxxxxxx
   3947                                                                  udiv.  */
   3948                                                               return 1971;
   3949                                                             }
   3950                                                           else
   3951                                                             {
   3952                                                               /* 33222222222211111111110000000000
   3953                                                                  10987654321098765432109876543210
   3954                                                                  000001x0xx0x1101000xxxxxxxxxxxxx
   3955                                                                  uabd.  */
   3956                                                               return 1962;
   3957                                                             }
   3958                                                         }
   3959                                                     }
   3960                                                   else
   3961                                                     {
   3962                                                       if (((word >> 18) & 0x1) == 0)
   3963                                                         {
   3964                                                           if (((word >> 19) & 0x1) == 0)
   3965                                                             {
   3966                                                               if (((word >> 20) & 0x1) == 0)
   3967                                                                 {
   3968                                                                   /* 33222222222211111111110000000000
   3969                                                                      10987654321098765432109876543210
   3970                                                                      000001x0xx000011000xxxxxxxxxxxxx
   3971                                                                      subr.  */
   3972                                                                   return 1951;
   3973                                                                 }
   3974                                                               else
   3975                                                                 {
   3976                                                                   /* 33222222222211111111110000000000
   3977                                                                      10987654321098765432109876543210
   3978                                                                      000001x0xx010011000xxxxxxxxxxxxx
   3979                                                                      umulh.  */
   3980                                                                   return 1982;
   3981                                                                 }
   3982                                                             }
   3983                                                           else
   3984                                                             {
   3985                                                               if (((word >> 20) & 0x1) == 0)
   3986                                                                 {
   3987                                                                   /* 33222222222211111111110000000000
   3988                                                                      10987654321098765432109876543210
   3989                                                                      000001x0xx001011000xxxxxxxxxxxxx
   3990                                                                      umin.  */
   3991                                                                   return 1980;
   3992                                                                 }
   3993                                                               else
   3994                                                                 {
   3995                                                                   /* 33222222222211111111110000000000
   3996                                                                      10987654321098765432109876543210
   3997                                                                      000001x0xx011011000xxxxxxxxxxxxx
   3998                                                                      bic.  */
   3999                                                                   return 1300;
   4000                                                                 }
   4001                                                             }
   4002                                                         }
   4003                                                       else
   4004                                                         {
   4005                                                           /* 33222222222211111111110000000000
   4006                                                              10987654321098765432109876543210
   4007                                                              000001x0xx0xx111000xxxxxxxxxxxxx
   4008                                                              udivr.  */
   4009                                                           return 1972;
   4010                                                         }
   4011                                                     }
   4012                                                 }
   4013                                             }
   4014                                           else
   4015                                             {
   4016                                               if (((word >> 23) & 0x1) == 0)
   4017                                                 {
   4018                                                   /* 33222222222211111111110000000000
   4019                                                      10987654321098765432109876543210
   4020                                                      100001x00x0xxxxx000xxxxxxxxxxxxx
   4021                                                      ld1sb.  */
   4022                                                   return 1562;
   4023                                                 }
   4024                                               else
   4025                                                 {
   4026                                                   /* 33222222222211111111110000000000
   4027                                                      10987654321098765432109876543210
   4028                                                      100001x01x0xxxxx000xxxxxxxxxxxxx
   4029                                                      ld1sh.  */
   4030                                                   return 1573;
   4031                                                 }
   4032                                             }
   4033                                         }
   4034                                       else
   4035                                         {
   4036                                           if (((word >> 31) & 0x1) == 0)
   4037                                             {
   4038                                               if (((word >> 12) & 0x1) == 0)
   4039                                                 {
   4040                                                   if (((word >> 10) & 0x1) == 0)
   4041                                                     {
   4042                                                       if (((word >> 11) & 0x1) == 0)
   4043                                                         {
   4044                                                           /* 33222222222211111111110000000000
   4045                                                              10987654321098765432109876543210
   4046                                                              010001x0xx0xxxxx000000xxxxxxxxxx
   4047                                                              sdot.  */
   4048                                                           return 1821;
   4049                                                         }
   4050                                                       else
   4051                                                         {
   4052                                                           /* 33222222222211111111110000000000
   4053                                                              10987654321098765432109876543210
   4054                                                              010001x0xx0xxxxx000010xxxxxxxxxx
   4055                                                              sqdmlalbt.  */
   4056                                                           return 2171;
   4057                                                         }
   4058                                                     }
   4059                                                   else
   4060                                                     {
   4061                                                       if (((word >> 11) & 0x1) == 0)
   4062                                                         {
   4063                                                           /* 33222222222211111111110000000000
   4064                                                              10987654321098765432109876543210
   4065                                                              010001x0xx0xxxxx000001xxxxxxxxxx
   4066                                                              udot.  */
   4067                                                           return 1973;
   4068                                                         }
   4069                                                       else
   4070                                                         {
   4071                                                           /* 33222222222211111111110000000000
   4072                                                              10987654321098765432109876543210
   4073                                                              010001x0xx0xxxxx000011xxxxxxxxxx
   4074                                                              sqdmlslbt.  */
   4075                                                           return 2178;
   4076                                                         }
   4077                                                     }
   4078                                                 }
   4079                                               else
   4080                                                 {
   4081                                                   /* 33222222222211111111110000000000
   4082                                                      10987654321098765432109876543210
   4083                                                      010001x0xx0xxxxx0001xxxxxxxxxxxx
   4084                                                      cdot.  */
   4085                                                   return 2060;
   4086                                                 }
   4087                                             }
   4088                                           else
   4089                                             {
   4090                                               if (((word >> 23) & 0x1) == 0)
   4091                                                 {
   4092                                                   /* 33222222222211111111110000000000
   4093                                                      10987654321098765432109876543210
   4094                                                      110001x00x0xxxxx000xxxxxxxxxxxxx
   4095                                                      ld1sb.  */
   4096                                                   return 1566;
   4097                                                 }
   4098                                               else
   4099                                                 {
   4100                                                   /* 33222222222211111111110000000000
   4101                                                      10987654321098765432109876543210
   4102                                                      110001x01x0xxxxx000xxxxxxxxxxxxx
   4103                                                      ld1sh.  */
   4104                                                   return 1577;
   4105                                                 }
   4106                                             }
   4107                                         }
   4108                                     }
   4109                                   else
   4110                                     {
   4111                                       if (((word >> 30) & 0x1) == 0)
   4112                                         {
   4113                                           if (((word >> 31) & 0x1) == 0)
   4114                                             {
   4115                                               if (((word >> 10) & 0x1) == 0)
   4116                                                 {
   4117                                                   if (((word >> 11) & 0x1) == 0)
   4118                                                     {
   4119                                                       if (((word >> 12) & 0x1) == 0)
   4120                                                         {
   4121                                                           /* 33222222222211111111110000000000
   4122                                                              10987654321098765432109876543210
   4123                                                              000001x0xx1xxxxx000000xxxxxxxxxx
   4124                                                              add.  */
   4125                                                           return 1278;
   4126                                                         }
   4127                                                       else
   4128                                                         {
   4129                                                           /* 33222222222211111111110000000000
   4130                                                              10987654321098765432109876543210
   4131                                                              000001x0xx1xxxxx000100xxxxxxxxxx
   4132                                                              sqadd.  */
   4133                                                           return 1835;
   4134                                                         }
   4135                                                     }
   4136                                                   else
   4137                                                     {
   4138                                                       /* 33222222222211111111110000000000
   4139                                                          10987654321098765432109876543210
   4140                                                          000001x0xx1xxxxx000x10xxxxxxxxxx
   4141                                                          sqsub.  */
   4142                                                       return 1865;
   4143                                                     }
   4144                                                 }
   4145                                               else
   4146                                                 {
   4147                                                   if (((word >> 11) & 0x1) == 0)
   4148                                                     {
   4149                                                       if (((word >> 12) & 0x1) == 0)
   4150                                                         {
   4151                                                           /* 33222222222211111111110000000000
   4152                                                              10987654321098765432109876543210
   4153                                                              000001x0xx1xxxxx000001xxxxxxxxxx
   4154                                                              sub.  */
   4155                                                           return 1947;
   4156                                                         }
   4157                                                       else
   4158                                                         {
   4159                                                           /* 33222222222211111111110000000000
   4160                                                              10987654321098765432109876543210
   4161                                                              000001x0xx1xxxxx000101xxxxxxxxxx
   4162                                                              uqadd.  */
   4163                                                           return 1983;
   4164                                                         }
   4165                                                     }
   4166                                                   else
   4167                                                     {
   4168                                                       /* 33222222222211111111110000000000
   4169                                                          10987654321098765432109876543210
   4170                                                          000001x0xx1xxxxx000x11xxxxxxxxxx
   4171                                                          uqsub.  */
   4172                                                       return 2013;
   4173                                                     }
   4174                                                 }
   4175                                             }
   4176                                           else
   4177                                             {
   4178                                               if (((word >> 23) & 0x1) == 0)
   4179                                                 {
   4180                                                   /* 33222222222211111111110000000000
   4181                                                      10987654321098765432109876543210
   4182                                                      100001x00x1xxxxx000xxxxxxxxxxxxx
   4183                                                      prfb.  */
   4184                                                   return 1768;
   4185                                                 }
   4186                                               else
   4187                                                 {
   4188                                                   /* 33222222222211111111110000000000
   4189                                                      10987654321098765432109876543210
   4190                                                      100001x01x1xxxxx000xxxxxxxxxxxxx
   4191                                                      ld1sh.  */
   4192                                                   return 1574;
   4193                                                 }
   4194                                             }
   4195                                         }
   4196                                       else
   4197                                         {
   4198                                           if (((word >> 23) & 0x1) == 0)
   4199                                             {
   4200                                               if (((word >> 31) & 0x1) == 0)
   4201                                                 {
   4202                                                   if (((word >> 10) & 0x1) == 0)
   4203                                                     {
   4204                                                       if (((word >> 11) & 0x1) == 0)
   4205                                                         {
   4206                                                           /* 33222222222211111111110000000000
   4207                                                              10987654321098765432109876543210
   4208                                                              010001x00x1xxxxx000x00xxxxxxxxxx
   4209                                                              sqrdmlah.  */
   4210                                                           return 2196;
   4211                                                         }
   4212                                                       else
   4213                                                         {
   4214                                                           /* 33222222222211111111110000000000
   4215                                                              10987654321098765432109876543210
   4216                                                              010001x00x1xxxxx000x10xxxxxxxxxx
   4217                                                              mla.  */
   4218                                                           return 2103;
   4219                                                         }
   4220                                                     }
   4221                                                   else
   4222                                                     {
   4223                                                       if (((word >> 11) & 0x1) == 0)
   4224                                                         {
   4225                                                           /* 33222222222211111111110000000000
   4226                                                              10987654321098765432109876543210
   4227                                                              010001x00x1xxxxx000x01xxxxxxxxxx
   4228                                                              sqrdmlsh.  */
   4229                                                           return 2200;
   4230                                                         }
   4231                                                       else
   4232                                                         {
   4233                                                           /* 33222222222211111111110000000000
   4234                                                              10987654321098765432109876543210
   4235                                                              010001x00x1xxxxx000x11xxxxxxxxxx
   4236                                                              mls.  */
   4237                                                           return 2106;
   4238                                                         }
   4239                                                     }
   4240                                                 }
   4241                                               else
   4242                                                 {
   4243                                                   /* 33222222222211111111110000000000
   4244                                                      10987654321098765432109876543210
   4245                                                      110001x00x1xxxxx000xxxxxxxxxxxxx
   4246                                                      prfb.  */
   4247                                                   return 1769;
   4248                                                 }
   4249                                             }
   4250                                           else
   4251                                             {
   4252                                               if (((word >> 31) & 0x1) == 0)
   4253                                                 {
   4254                                                   if (((word >> 10) & 0x1) == 0)
   4255                                                     {
   4256                                                       if (((word >> 11) & 0x1) == 0)
   4257                                                         {
   4258                                                           if (((word >> 12) & 0x1) == 0)
   4259                                                             {
   4260                                                               if (((word >> 22) & 0x1) == 0)
   4261                                                                 {
   4262                                                                   /* 33222222222211111111110000000000
   4263                                                                      10987654321098765432109876543210
   4264                                                                      010001x0101xxxxx000000xxxxxxxxxx
   4265                                                                      sdot.  */
   4266                                                                   return 1822;
   4267                                                                 }
   4268                                                               else
   4269                                                                 {
   4270                                                                   /* 33222222222211111111110000000000
   4271                                                                      10987654321098765432109876543210
   4272                                                                      010001x0111xxxxx000000xxxxxxxxxx
   4273                                                                      sdot.  */
   4274                                                                   return 1823;
   4275                                                                 }
   4276                                                             }
   4277                                                           else
   4278                                                             {
   4279                                                               if (((word >> 22) & 0x1) == 0)
   4280                                                                 {
   4281                                                                   /* 33222222222211111111110000000000
   4282                                                                      10987654321098765432109876543210
   4283                                                                      010001x0101xxxxx000100xxxxxxxxxx
   4284                                                                      sqrdmlah.  */
   4285                                                                   return 2197;
   4286                                                                 }
   4287                                                               else
   4288                                                                 {
   4289                                                                   /* 33222222222211111111110000000000
   4290                                                                      10987654321098765432109876543210
   4291                                                                      010001x0111xxxxx000100xxxxxxxxxx
   4292                                                                      sqrdmlah.  */
   4293                                                                   return 2198;
   4294                                                                 }
   4295                                                             }
   4296                                                         }
   4297                                                       else
   4298                                                         {
   4299                                                           if (((word >> 12) & 0x1) == 0)
   4300                                                             {
   4301                                                               if (((word >> 22) & 0x1) == 0)
   4302                                                                 {
   4303                                                                   /* 33222222222211111111110000000000
   4304                                                                      10987654321098765432109876543210
   4305                                                                      010001x0101xxxxx000010xxxxxxxxxx
   4306                                                                      mla.  */
   4307                                                                   return 2104;
   4308                                                                 }
   4309                                                               else
   4310                                                                 {
   4311                                                                   /* 33222222222211111111110000000000
   4312                                                                      10987654321098765432109876543210
   4313                                                                      010001x0111xxxxx000010xxxxxxxxxx
   4314                                                                      mla.  */
   4315                                                                   return 2105;
   4316                                                                 }
   4317                                                             }
   4318                                                           else
   4319                                                             {
   4320                                                               /* 33222222222211111111110000000000
   4321                                                                  10987654321098765432109876543210
   4322                                                                  010001x01x1xxxxx000110xxxxxxxxxx
   4323                                                                  usdot.  */
   4324                                                               return 2398;
   4325                                                             }
   4326                                                         }
   4327                                                     }
   4328                                                   else
   4329                                                     {
   4330                                                       if (((word >> 11) & 0x1) == 0)
   4331                                                         {
   4332                                                           if (((word >> 12) & 0x1) == 0)
   4333                                                             {
   4334                                                               if (((word >> 22) & 0x1) == 0)
   4335                                                                 {
   4336                                                                   /* 33222222222211111111110000000000
   4337                                                                      10987654321098765432109876543210
   4338                                                                      010001x0101xxxxx000001xxxxxxxxxx
   4339                                                                      udot.  */
   4340                                                                   return 1974;
   4341                                                                 }
   4342                                                               else
   4343                                                                 {
   4344                                                                   /* 33222222222211111111110000000000
   4345                                                                      10987654321098765432109876543210
   4346                                                                      010001x0111xxxxx000001xxxxxxxxxx
   4347                                                                      udot.  */
   4348                                                                   return 1975;
   4349                                                                 }
   4350                                                             }
   4351                                                           else
   4352                                                             {
   4353                                                               if (((word >> 22) & 0x1) == 0)
   4354                                                                 {
   4355                                                                   /* 33222222222211111111110000000000
   4356                                                                      10987654321098765432109876543210
   4357                                                                      010001x0101xxxxx000101xxxxxxxxxx
   4358                                                                      sqrdmlsh.  */
   4359                                                                   return 2201;
   4360                                                                 }
   4361                                                               else
   4362                                                                 {
   4363                                                                   /* 33222222222211111111110000000000
   4364                                                                      10987654321098765432109876543210
   4365                                                                      010001x0111xxxxx000101xxxxxxxxxx
   4366                                                                      sqrdmlsh.  */
   4367                                                                   return 2202;
   4368                                                                 }
   4369                                                             }
   4370                                                         }
   4371                                                       else
   4372                                                         {
   4373                                                           if (((word >> 12) & 0x1) == 0)
   4374                                                             {
   4375                                                               if (((word >> 22) & 0x1) == 0)
   4376                                                                 {
   4377                                                                   /* 33222222222211111111110000000000
   4378                                                                      10987654321098765432109876543210
   4379                                                                      010001x0101xxxxx000011xxxxxxxxxx
   4380                                                                      mls.  */
   4381                                                                   return 2107;
   4382                                                                 }
   4383                                                               else
   4384                                                                 {
   4385                                                                   /* 33222222222211111111110000000000
   4386                                                                      10987654321098765432109876543210
   4387                                                                      010001x0111xxxxx000011xxxxxxxxxx
   4388                                                                      mls.  */
   4389                                                                   return 2108;
   4390                                                                 }
   4391                                                             }
   4392                                                           else
   4393                                                             {
   4394                                                               /* 33222222222211111111110000000000
   4395                                                                  10987654321098765432109876543210
   4396                                                                  010001x01x1xxxxx000111xxxxxxxxxx
   4397                                                                  sudot.  */
   4398                                                               return 2399;
   4399                                                             }
   4400                                                         }
   4401                                                     }
   4402                                                 }
   4403                                               else
   4404                                                 {
   4405                                                   /* 33222222222211111111110000000000
   4406                                                      10987654321098765432109876543210
   4407                                                      110001x01x1xxxxx000xxxxxxxxxxxxx
   4408                                                      ld1sh.  */
   4409                                                   return 1578;
   4410                                                 }
   4411                                             }
   4412                                         }
   4413                                     }
   4414                                 }
   4415                               else
   4416                                 {
   4417                                   if (((word >> 31) & 0x1) == 0)
   4418                                     {
   4419                                       if (((word >> 21) & 0x1) == 0)
   4420                                         {
   4421                                           if (((word >> 16) & 0x1) == 0)
   4422                                             {
   4423                                               if (((word >> 17) & 0x1) == 0)
   4424                                                 {
   4425                                                   if (((word >> 18) & 0x1) == 0)
   4426                                                     {
   4427                                                       if (((word >> 19) & 0x1) == 0)
   4428                                                         {
   4429                                                           if (((word >> 20) & 0x1) == 0)
   4430                                                             {
   4431                                                               /* 33222222222211111111110000000000
   4432                                                                  10987654321098765432109876543210
   4433                                                                  0x0001x0xx000000100xxxxxxxxxxxxx
   4434                                                                  asr.  */
   4435                                                               return 1296;
   4436                                                             }
   4437                                                           else
   4438                                                             {
   4439                                                               if (((word >> 30) & 0x1) == 0)
   4440                                                                 {
   4441                                                                   /* 33222222222211111111110000000000
   4442                                                                      10987654321098765432109876543210
   4443                                                                      000001x0xx010000100xxxxxxxxxxxxx
   4444                                                                      asr.  */
   4445                                                                   return 1294;
   4446                                                                 }
   4447                                                               else
   4448                                                                 {
   4449                                                                   /* 33222222222211111111110000000000
   4450                                                                      10987654321098765432109876543210
   4451                                                                      010001x0xx010000100xxxxxxxxxxxxx
   4452                                                                      shadd.  */
   4453                                                                   return 2137;
   4454                                                                 }
   4455                                                             }
   4456                                                         }
   4457                                                       else
   4458                                                         {
   4459                                                           if (((word >> 20) & 0x1) == 0)
   4460                                                             {
   4461                                                               /* 33222222222211111111110000000000
   4462                                                                  10987654321098765432109876543210
   4463                                                                  0x0001x0xx001000100xxxxxxxxxxxxx
   4464                                                                  sqshl.  */
   4465                                                               return 2215;
   4466                                                             }
   4467                                                           else
   4468                                                             {
   4469                                                               if (((word >> 30) & 0x1) == 0)
   4470                                                                 {
   4471                                                                   /* 33222222222211111111110000000000
   4472                                                                      10987654321098765432109876543210
   4473                                                                      000001x0xx011000100xxxxxxxxxxxxx
   4474                                                                      asr.  */
   4475                                                                   return 1295;
   4476                                                                 }
   4477                                                               else
   4478                                                                 {
   4479                                                                   /* 33222222222211111111110000000000
   4480                                                                      10987654321098765432109876543210
   4481                                                                      010001x0xx011000100xxxxxxxxxxxxx
   4482                                                                      sqadd.  */
   4483                                                                   return 2166;
   4484                                                                 }
   4485                                                             }
   4486                                                         }
   4487                                                     }
   4488                                                   else
   4489                                                     {
   4490                                                       if (((word >> 19) & 0x1) == 0)
   4491                                                         {
   4492                                                           if (((word >> 20) & 0x1) == 0)
   4493                                                             {
   4494                                                               /* 33222222222211111111110000000000
   4495                                                                  10987654321098765432109876543210
   4496                                                                  0x0001x0xx000100100xxxxxxxxxxxxx
   4497                                                                  asrd.  */
   4498                                                               return 1297;
   4499                                                             }
   4500                                                           else
   4501                                                             {
   4502                                                               if (((word >> 30) & 0x1) == 0)
   4503                                                                 {
   4504                                                                   /* 33222222222211111111110000000000
   4505                                                                      10987654321098765432109876543210
   4506                                                                      000001x0xx010100100xxxxxxxxxxxxx
   4507                                                                      asrr.  */
   4508                                                                   return 1298;
   4509                                                                 }
   4510                                                               else
   4511                                                                 {
   4512                                                                   /* 33222222222211111111110000000000
   4513                                                                      10987654321098765432109876543210
   4514                                                                      010001x0xx010100100xxxxxxxxxxxxx
   4515                                                                      srhadd.  */
   4516                                                                   return 2228;
   4517                                                                 }
   4518                                                             }
   4519                                                         }
   4520                                                       else
   4521                                                         {
   4522                                                           if (((word >> 20) & 0x1) == 0)
   4523                                                             {
   4524                                                               if (((word >> 30) & 0x1) == 0)
   4525                                                                 {
   4526                                                                   /* 33222222222211111111110000000000
   4527                                                                      10987654321098765432109876543210
   4528                                                                      000001x0xx001100100xxxxxxxxxxxxx
   4529                                                                      srshr.  */
   4530                                                                   return 2232;
   4531                                                                 }
   4532                                                               else
   4533                                                                 {
   4534                                                                   /* 33222222222211111111110000000000
   4535                                                                      10987654321098765432109876543210
   4536                                                                      010001x0xx001100100xxxxxxxxxxxxx
   4537                                                                      sqshlr.  */
   4538                                                                   return 2216;
   4539                                                                 }
   4540                                                             }
   4541                                                           else
   4542                                                             {
   4543                                                               /* 33222222222211111111110000000000
   4544                                                                  10987654321098765432109876543210
   4545                                                                  0x0001x0xx011100100xxxxxxxxxxxxx
   4546                                                                  suqadd.  */
   4547                                                               return 2252;
   4548                                                             }
   4549                                                         }
   4550                                                     }
   4551                                                 }
   4552                                               else
   4553                                                 {
   4554                                                   if (((word >> 18) & 0x1) == 0)
   4555                                                     {
   4556                                                       if (((word >> 19) & 0x1) == 0)
   4557                                                         {
   4558                                                           if (((word >> 20) & 0x1) == 0)
   4559                                                             {
   4560                                                               /* 33222222222211111111110000000000
   4561                                                                  10987654321098765432109876543210
   4562                                                                  0x0001x0xx000010100xxxxxxxxxxxxx
   4563                                                                  srshl.  */
   4564                                                               return 2230;
   4565                                                             }
   4566                                                           else
   4567                                                             {
   4568                                                               /* 33222222222211111111110000000000
   4569                                                                  10987654321098765432109876543210
   4570                                                                  0x0001x0xx010010100xxxxxxxxxxxxx
   4571                                                                  shsub.  */
   4572                                                               return 2140;
   4573                                                             }
   4574                                                         }
   4575                                                       else
   4576                                                         {
   4577                                                           if (((word >> 20) & 0x1) == 0)
   4578                                                             {
   4579                                                               /* 33222222222211111111110000000000
   4580                                                                  10987654321098765432109876543210
   4581                                                                  0x0001x0xx001010100xxxxxxxxxxxxx
   4582                                                                  sqrshl.  */
   4583                                                               return 2208;
   4584                                                             }
   4585                                                           else
   4586                                                             {
   4587                                                               /* 33222222222211111111110000000000
   4588                                                                  10987654321098765432109876543210
   4589                                                                  0x0001x0xx011010100xxxxxxxxxxxxx
   4590                                                                  sqsub.  */
   4591                                                               return 2222;
   4592                                                             }
   4593                                                         }
   4594                                                     }
   4595                                                   else
   4596                                                     {
   4597                                                       if (((word >> 19) & 0x1) == 0)
   4598                                                         {
   4599                                                           if (((word >> 20) & 0x1) == 0)
   4600                                                             {
   4601                                                               if (((word >> 30) & 0x1) == 0)
   4602                                                                 {
   4603                                                                   /* 33222222222211111111110000000000
   4604                                                                      10987654321098765432109876543210
   4605                                                                      000001x0xx000110100xxxxxxxxxxxxx
   4606                                                                      sqshl.  */
   4607                                                                   return 2214;
   4608                                                                 }
   4609                                                               else
   4610                                                                 {
   4611                                                                   /* 33222222222211111111110000000000
   4612                                                                      10987654321098765432109876543210
   4613                                                                      010001x0xx000110100xxxxxxxxxxxxx
   4614                                                                      srshlr.  */
   4615                                                                   return 2231;
   4616                                                                 }
   4617                                                             }
   4618                                                           else
   4619                                                             {
   4620                                                               /* 33222222222211111111110000000000
   4621                                                                  10987654321098765432109876543210
   4622                                                                  0x0001x0xx010110100xxxxxxxxxxxxx
   4623                                                                  shsubr.  */
   4624                                                               return 2141;
   4625                                                             }
   4626                                                         }
   4627                                                       else
   4628                                                         {
   4629                                                           if (((word >> 20) & 0x1) == 0)
   4630                                                             {
   4631                                                               /* 33222222222211111111110000000000
   4632                                                                  10987654321098765432109876543210
   4633                                                                  0x0001x0xx001110100xxxxxxxxxxxxx
   4634                                                                  sqrshlr.  */
   4635                                                               return 2209;
   4636                                                             }
   4637                                                           else
   4638                                                             {
   4639                                                               /* 33222222222211111111110000000000
   4640                                                                  10987654321098765432109876543210
   4641                                                                  0x0001x0xx011110100xxxxxxxxxxxxx
   4642                                                                  sqsubr.  */
   4643                                                               return 2223;
   4644                                                             }
   4645                                                         }
   4646                                                     }
   4647                                                 }
   4648                                             }
   4649                                           else
   4650                                             {
   4651                                               if (((word >> 17) & 0x1) == 0)
   4652                                                 {
   4653                                                   if (((word >> 18) & 0x1) == 0)
   4654                                                     {
   4655                                                       if (((word >> 19) & 0x1) == 0)
   4656                                                         {
   4657                                                           if (((word >> 20) & 0x1) == 0)
   4658                                                             {
   4659                                                               /* 33222222222211111111110000000000
   4660                                                                  10987654321098765432109876543210
   4661                                                                  0x0001x0xx000001100xxxxxxxxxxxxx
   4662                                                                  lsr.  */
   4663                                                               return 1740;
   4664                                                             }
   4665                                                           else
   4666                                                             {
   4667                                                               if (((word >> 30) & 0x1) == 0)
   4668                                                                 {
   4669                                                                   /* 33222222222211111111110000000000
   4670                                                                      10987654321098765432109876543210
   4671                                                                      000001x0xx010001100xxxxxxxxxxxxx
   4672                                                                      lsr.  */
   4673                                                                   return 1738;
   4674                                                                 }
   4675                                                               else
   4676                                                                 {
   4677                                                                   /* 33222222222211111111110000000000
   4678                                                                      10987654321098765432109876543210
   4679                                                                      010001x0xx010001100xxxxxxxxxxxxx
   4680                                                                      uhadd.  */
   4681                                                                   return 2265;
   4682                                                                 }
   4683                                                             }
   4684                                                         }
   4685                                                       else
   4686                                                         {
   4687                                                           if (((word >> 20) & 0x1) == 0)
   4688                                                             {
   4689                                                               /* 33222222222211111111110000000000
   4690                                                                  10987654321098765432109876543210
   4691                                                                  0x0001x0xx001001100xxxxxxxxxxxxx
   4692                                                                  uqshl.  */
   4693                                                               return 2295;
   4694                                                             }
   4695                                                           else
   4696                                                             {
   4697                                                               if (((word >> 30) & 0x1) == 0)
   4698                                                                 {
   4699                                                                   /* 33222222222211111111110000000000
   4700                                                                      10987654321098765432109876543210
   4701                                                                      000001x0xx011001100xxxxxxxxxxxxx
   4702                                                                      lsr.  */
   4703                                                                   return 1739;
   4704                                                                 }
   4705                                                               else
   4706                                                                 {
   4707                                                                   /* 33222222222211111111110000000000
   4708                                                                      10987654321098765432109876543210
   4709                                                                      010001x0xx011001100xxxxxxxxxxxxx
   4710                                                                      uqadd.  */
   4711                                                                   return 2289;
   4712                                                                 }
   4713                                                             }
   4714                                                         }
   4715                                                     }
   4716                                                   else
   4717                                                     {
   4718                                                       if (((word >> 19) & 0x1) == 0)
   4719                                                         {
   4720                                                           if (((word >> 30) & 0x1) == 0)
   4721                                                             {
   4722                                                               /* 33222222222211111111110000000000
   4723                                                                  10987654321098765432109876543210
   4724                                                                  000001x0xx0x0101100xxxxxxxxxxxxx
   4725                                                                  lsrr.  */
   4726                                                               return 1741;
   4727                                                             }
   4728                                                           else
   4729                                                             {
   4730                                                               /* 33222222222211111111110000000000
   4731                                                                  10987654321098765432109876543210
   4732                                                                  010001x0xx0x0101100xxxxxxxxxxxxx
   4733                                                                  urhadd.  */
   4734                                                               return 2304;
   4735                                                             }
   4736                                                         }
   4737                                                       else
   4738                                                         {
   4739                                                           if (((word >> 20) & 0x1) == 0)
   4740                                                             {
   4741                                                               if (((word >> 30) & 0x1) == 0)
   4742                                                                 {
   4743                                                                   /* 33222222222211111111110000000000
   4744                                                                      10987654321098765432109876543210
   4745                                                                      000001x0xx001101100xxxxxxxxxxxxx
   4746                                                                      urshr.  */
   4747                                                                   return 2307;
   4748                                                                 }
   4749                                                               else
   4750                                                                 {
   4751                                                                   /* 33222222222211111111110000000000
   4752                                                                      10987654321098765432109876543210
   4753                                                                      010001x0xx001101100xxxxxxxxxxxxx
   4754                                                                      uqshlr.  */
   4755                                                                   return 2296;
   4756                                                                 }
   4757                                                             }
   4758                                                           else
   4759                                                             {
   4760                                                               /* 33222222222211111111110000000000
   4761                                                                  10987654321098765432109876543210
   4762                                                                  0x0001x0xx011101100xxxxxxxxxxxxx
   4763                                                                  usqadd.  */
   4764                                                               return 2312;
   4765                                                             }
   4766                                                         }
   4767                                                     }
   4768                                                 }
   4769                                               else
   4770                                                 {
   4771                                                   if (((word >> 18) & 0x1) == 0)
   4772                                                     {
   4773                                                       if (((word >> 19) & 0x1) == 0)
   4774                                                         {
   4775                                                           if (((word >> 20) & 0x1) == 0)
   4776                                                             {
   4777                                                               if (((word >> 30) & 0x1) == 0)
   4778                                                                 {
   4779                                                                   /* 33222222222211111111110000000000
   4780                                                                      10987654321098765432109876543210
   4781                                                                      000001x0xx000011100xxxxxxxxxxxxx
   4782                                                                      lsl.  */
   4783                                                                   return 1734;
   4784                                                                 }
   4785                                                               else
   4786                                                                 {
   4787                                                                   /* 33222222222211111111110000000000
   4788                                                                      10987654321098765432109876543210
   4789                                                                      010001x0xx000011100xxxxxxxxxxxxx
   4790                                                                      urshl.  */
   4791                                                                   return 2305;
   4792                                                                 }
   4793                                                             }
   4794                                                           else
   4795                                                             {
   4796                                                               if (((word >> 30) & 0x1) == 0)
   4797                                                                 {
   4798                                                                   /* 33222222222211111111110000000000
   4799                                                                      10987654321098765432109876543210
   4800                                                                      000001x0xx010011100xxxxxxxxxxxxx
   4801                                                                      lsl.  */
   4802                                                                   return 1732;
   4803                                                                 }
   4804                                                               else
   4805                                                                 {
   4806                                                                   /* 33222222222211111111110000000000
   4807                                                                      10987654321098765432109876543210
   4808                                                                      010001x0xx010011100xxxxxxxxxxxxx
   4809                                                                      uhsub.  */
   4810                                                                   return 2266;
   4811                                                                 }
   4812                                                             }
   4813                                                         }
   4814                                                       else
   4815                                                         {
   4816                                                           if (((word >> 20) & 0x1) == 0)
   4817                                                             {
   4818                                                               /* 33222222222211111111110000000000
   4819                                                                  10987654321098765432109876543210
   4820                                                                  0x0001x0xx001011100xxxxxxxxxxxxx
   4821                                                                  uqrshl.  */
   4822                                                               return 2290;
   4823                                                             }
   4824                                                           else
   4825                                                             {
   4826                                                               if (((word >> 30) & 0x1) == 0)
   4827                                                                 {
   4828                                                                   /* 33222222222211111111110000000000
   4829                                                                      10987654321098765432109876543210
   4830                                                                      000001x0xx011011100xxxxxxxxxxxxx
   4831                                                                      lsl.  */
   4832                                                                   return 1733;
   4833                                                                 }
   4834                                                               else
   4835                                                                 {
   4836                                                                   /* 33222222222211111111110000000000
   4837                                                                      10987654321098765432109876543210
   4838                                                                      010001x0xx011011100xxxxxxxxxxxxx
   4839                                                                      uqsub.  */
   4840                                                                   return 2299;
   4841                                                                 }
   4842                                                             }
   4843                                                         }
   4844                                                     }
   4845                                                   else
   4846                                                     {
   4847                                                       if (((word >> 19) & 0x1) == 0)
   4848                                                         {
   4849                                                           if (((word >> 20) & 0x1) == 0)
   4850                                                             {
   4851                                                               if (((word >> 30) & 0x1) == 0)
   4852                                                                 {
   4853                                                                   /* 33222222222211111111110000000000
   4854                                                                      10987654321098765432109876543210
   4855                                                                      000001x0xx000111100xxxxxxxxxxxxx
   4856                                                                      uqshl.  */
   4857                                                                   return 2294;
   4858                                                                 }
   4859                                                               else
   4860                                                                 {
   4861                                                                   /* 33222222222211111111110000000000
   4862                                                                      10987654321098765432109876543210
   4863                                                                      010001x0xx000111100xxxxxxxxxxxxx
   4864                                                                      urshlr.  */
   4865                                                                   return 2306;
   4866                                                                 }
   4867                                                             }
   4868                                                           else
   4869                                                             {
   4870                                                               if (((word >> 30) & 0x1) == 0)
   4871                                                                 {
   4872                                                                   /* 33222222222211111111110000000000
   4873                                                                      10987654321098765432109876543210
   4874                                                                      000001x0xx010111100xxxxxxxxxxxxx
   4875                                                                      lslr.  */
   4876                                                                   return 1735;
   4877                                                                 }
   4878                                                               else
   4879                                                                 {
   4880                                                                   /* 33222222222211111111110000000000
   4881                                                                      10987654321098765432109876543210
   4882                                                                      010001x0xx010111100xxxxxxxxxxxxx
   4883                                                                      uhsubr.  */
   4884                                                                   return 2267;
   4885                                                                 }
   4886                                                             }
   4887                                                         }
   4888                                                       else
   4889                                                         {
   4890                                                           if (((word >> 20) & 0x1) == 0)
   4891                                                             {
   4892                                                               if (((word >> 30) & 0x1) == 0)
   4893                                                                 {
   4894                                                                   /* 33222222222211111111110000000000
   4895                                                                      10987654321098765432109876543210
   4896                                                                      000001x0xx001111100xxxxxxxxxxxxx
   4897                                                                      sqshlu.  */
   4898                                                                   return 2217;
   4899                                                                 }
   4900                                                               else
   4901                                                                 {
   4902                                                                   /* 33222222222211111111110000000000
   4903                                                                      10987654321098765432109876543210
   4904                                                                      010001x0xx001111100xxxxxxxxxxxxx
   4905                                                                      uqrshlr.  */
   4906                                                                   return 2291;
   4907                                                                 }
   4908                                                             }
   4909                                                           else
   4910                                                             {
   4911                                                               /* 33222222222211111111110000000000
   4912                                                                  10987654321098765432109876543210
   4913                                                                  0x0001x0xx011111100xxxxxxxxxxxxx
   4914                                                                  uqsubr.  */
   4915                                                               return 2300;
   4916                                                             }
   4917                                                         }
   4918                                                     }
   4919                                                 }
   4920                                             }
   4921                                         }
   4922                                       else
   4923                                         {
   4924                                           if (((word >> 10) & 0x1) == 0)
   4925                                             {
   4926                                               if (((word >> 12) & 0x1) == 0)
   4927                                                 {
   4928                                                   if (((word >> 30) & 0x1) == 0)
   4929                                                     {
   4930                                                       /* 33222222222211111111110000000000
   4931                                                          10987654321098765432109876543210
   4932                                                          000001x0xx1xxxxx1000x0xxxxxxxxxx
   4933                                                          asr.  */
   4934                                                       return 1292;
   4935                                                     }
   4936                                                   else
   4937                                                     {
   4938                                                       if (((word >> 22) & 0x1) == 0)
   4939                                                         {
   4940                                                           /* 33222222222211111111110000000000
   4941                                                              10987654321098765432109876543210
   4942                                                              010001x0x01xxxxx1000x0xxxxxxxxxx
   4943                                                              smlalb.  */
   4944                                                           return 2145;
   4945                                                         }
   4946                                                       else
   4947                                                         {
   4948                                                           /* 33222222222211111111110000000000
   4949                                                              10987654321098765432109876543210
   4950                                                              010001x0x11xxxxx1000x0xxxxxxxxxx
   4951                                                              smlalb.  */
   4952                                                           return 2146;
   4953                                                         }
   4954                                                     }
   4955                                                 }
   4956                                               else
   4957                                                 {
   4958                                                   if (((word >> 30) & 0x1) == 0)
   4959                                                     {
   4960                                                       /* 33222222222211111111110000000000
   4961                                                          10987654321098765432109876543210
   4962                                                          000001x0xx1xxxxx1001x0xxxxxxxxxx
   4963                                                          asr.  */
   4964                                                       return 1293;
   4965                                                     }
   4966                                                   else
   4967                                                     {
   4968                                                       if (((word >> 22) & 0x1) == 0)
   4969                                                         {
   4970                                                           /* 33222222222211111111110000000000
   4971                                                              10987654321098765432109876543210
   4972                                                              010001x0x01xxxxx1001x0xxxxxxxxxx
   4973                                                              umlalb.  */
   4974                                                           return 2270;
   4975                                                         }
   4976                                                       else
   4977                                                         {
   4978                                                           /* 33222222222211111111110000000000
   4979                                                              10987654321098765432109876543210
   4980                                                              010001x0x11xxxxx1001x0xxxxxxxxxx
   4981                                                              umlalb.  */
   4982                                                           return 2271;
   4983                                                         }
   4984                                                     }
   4985                                                 }
   4986                                             }
   4987                                           else
   4988                                             {
   4989                                               if (((word >> 12) & 0x1) == 0)
   4990                                                 {
   4991                                                   if (((word >> 30) & 0x1) == 0)
   4992                                                     {
   4993                                                       if (((word >> 11) & 0x1) == 0)
   4994                                                         {
   4995                                                           /* 33222222222211111111110000000000
   4996                                                              10987654321098765432109876543210
   4997                                                              000001x0xx1xxxxx100001xxxxxxxxxx
   4998                                                              lsr.  */
   4999                                                           return 1736;
   5000                                                         }
   5001                                                       else
   5002                                                         {
   5003                                                           /* 33222222222211111111110000000000
   5004                                                              10987654321098765432109876543210
   5005                                                              000001x0xx1xxxxx100011xxxxxxxxxx
   5006                                                              lsl.  */
   5007                                                           return 1730;
   5008                                                         }
   5009                                                     }
   5010                                                   else
   5011                                                     {
   5012                                                       if (((word >> 22) & 0x1) == 0)
   5013                                                         {
   5014                                                           /* 33222222222211111111110000000000
   5015                                                              10987654321098765432109876543210
   5016                                                              010001x0x01xxxxx1000x1xxxxxxxxxx
   5017                                                              smlalt.  */
   5018                                                           return 2148;
   5019                                                         }
   5020                                                       else
   5021                                                         {
   5022                                                           /* 33222222222211111111110000000000
   5023                                                              10987654321098765432109876543210
   5024                                                              010001x0x11xxxxx1000x1xxxxxxxxxx
   5025                                                              smlalt.  */
   5026                                                           return 2149;
   5027                                                         }
   5028                                                     }
   5029                                                 }
   5030                                               else
   5031                                                 {
   5032                                                   if (((word >> 30) & 0x1) == 0)
   5033                                                     {
   5034                                                       if (((word >> 11) & 0x1) == 0)
   5035                                                         {
   5036                                                           /* 33222222222211111111110000000000
   5037                                                              10987654321098765432109876543210
   5038                                                              000001x0xx1xxxxx100101xxxxxxxxxx
   5039                                                              lsr.  */
   5040                                                           return 1737;
   5041                                                         }
   5042                                                       else
   5043                                                         {
   5044                                                           /* 33222222222211111111110000000000
   5045                                                              10987654321098765432109876543210
   5046                                                              000001x0xx1xxxxx100111xxxxxxxxxx
   5047                                                              lsl.  */
   5048                                                           return 1731;
   5049                                                         }
   5050                                                     }
   5051                                                   else
   5052                                                     {
   5053                                                       if (((word >> 22) & 0x1) == 0)
   5054                                                         {
   5055                                                           /* 33222222222211111111110000000000
   5056                                                              10987654321098765432109876543210
   5057                                                              010001x0x01xxxxx1001x1xxxxxxxxxx
   5058                                                              umlalt.  */
   5059                                                           return 2273;
   5060                                                         }
   5061                                                       else
   5062                                                         {
   5063                                                           /* 33222222222211111111110000000000
   5064                                                              10987654321098765432109876543210
   5065                                                              010001x0x11xxxxx1001x1xxxxxxxxxx
   5066                                                              umlalt.  */
   5067                                                           return 2274;
   5068                                                         }
   5069                                                     }
   5070                                                 }
   5071                                             }
   5072                                         }
   5073                                     }
   5074                                   else
   5075                                     {
   5076                                       if (((word >> 22) & 0x1) == 0)
   5077                                         {
   5078                                           if (((word >> 21) & 0x1) == 0)
   5079                                             {
   5080                                               if (((word >> 23) & 0x1) == 0)
   5081                                                 {
   5082                                                   /* 33222222222211111111110000000000
   5083                                                      10987654321098765432109876543210
   5084                                                      1x0001x0000xxxxx100xxxxxxxxxxxxx
   5085                                                      ldnt1sb.  */
   5086                                                   return 2097;
   5087                                                 }
   5088                                               else
   5089                                                 {
   5090                                                   /* 33222222222211111111110000000000
   5091                                                      10987654321098765432109876543210
   5092                                                      1x0001x0100xxxxx100xxxxxxxxxxxxx
   5093                                                      ldnt1sh.  */
   5094                                                   return 2098;
   5095                                                 }
   5096                                             }
   5097                                           else
   5098                                             {
   5099                                               if (((word >> 23) & 0x1) == 0)
   5100                                                 {
   5101                                                   if (((word >> 30) & 0x1) == 0)
   5102                                                     {
   5103                                                       /* 33222222222211111111110000000000
   5104                                                          10987654321098765432109876543210
   5105                                                          100001x0001xxxxx100xxxxxxxxxxxxx
   5106                                                          ld1sb.  */
   5107                                                       return 1568;
   5108                                                     }
   5109                                                   else
   5110                                                     {
   5111                                                       /* 33222222222211111111110000000000
   5112                                                          10987654321098765432109876543210
   5113                                                          110001x0001xxxxx100xxxxxxxxxxxxx
   5114                                                          ld1sb.  */
   5115                                                       return 1572;
   5116                                                     }
   5117                                                 }
   5118                                               else
   5119                                                 {
   5120                                                   if (((word >> 30) & 0x1) == 0)
   5121                                                     {
   5122                                                       /* 33222222222211111111110000000000
   5123                                                          10987654321098765432109876543210
   5124                                                          100001x0101xxxxx100xxxxxxxxxxxxx
   5125                                                          ld1sh.  */
   5126                                                       return 1581;
   5127                                                     }
   5128                                                   else
   5129                                                     {
   5130                                                       /* 33222222222211111111110000000000
   5131                                                          10987654321098765432109876543210
   5132                                                          110001x0101xxxxx100xxxxxxxxxxxxx
   5133                                                          ld1sh.  */
   5134                                                       return 1584;
   5135                                                     }
   5136                                                 }
   5137                                             }
   5138                                         }
   5139                                       else
   5140                                         {
   5141                                           if (((word >> 23) & 0x1) == 0)
   5142                                             {
   5143                                               if (((word >> 30) & 0x1) == 0)
   5144                                                 {
   5145                                                   /* 33222222222211111111110000000000
   5146                                                      10987654321098765432109876543210
   5147                                                      100001x001xxxxxx100xxxxxxxxxxxxx
   5148                                                      ld1rb.  */
   5149                                                   return 1538;
   5150                                                 }
   5151                                               else
   5152                                                 {
   5153                                                   if (((word >> 21) & 0x1) == 0)
   5154                                                     {
   5155                                                       /* 33222222222211111111110000000000
   5156                                                          10987654321098765432109876543210
   5157                                                          110001x0010xxxxx100xxxxxxxxxxxxx
   5158                                                          ld1sb.  */
   5159                                                       return 1567;
   5160                                                     }
   5161                                                   else
   5162                                                     {
   5163                                                       /* 33222222222211111111110000000000
   5164                                                          10987654321098765432109876543210
   5165                                                          110001x0011xxxxx100xxxxxxxxxxxxx
   5166                                                          prfb.  */
   5167                                                       return 1770;
   5168                                                     }
   5169                                                 }
   5170                                             }
   5171                                           else
   5172                                             {
   5173                                               if (((word >> 30) & 0x1) == 0)
   5174                                                 {
   5175                                                   /* 33222222222211111111110000000000
   5176                                                      10987654321098765432109876543210
   5177                                                      100001x011xxxxxx100xxxxxxxxxxxxx
   5178                                                      ld1rsw.  */
   5179                                                   return 1559;
   5180                                                 }
   5181                                               else
   5182                                                 {
   5183                                                   if (((word >> 21) & 0x1) == 0)
   5184                                                     {
   5185                                                       /* 33222222222211111111110000000000
   5186                                                          10987654321098765432109876543210
   5187                                                          110001x0110xxxxx100xxxxxxxxxxxxx
   5188                                                          ld1sh.  */
   5189                                                       return 1579;
   5190                                                     }
   5191                                                   else
   5192                                                     {
   5193                                                       /* 33222222222211111111110000000000
   5194                                                          10987654321098765432109876543210
   5195                                                          110001x0111xxxxx100xxxxxxxxxxxxx
   5196                                                          ld1sh.  */
   5197                                                       return 1580;
   5198                                                     }
   5199                                                 }
   5200                                             }
   5201                                         }
   5202                                     }
   5203                                 }
   5204                             }
   5205                           else
   5206                             {
   5207                               if (((word >> 15) & 0x1) == 0)
   5208                                 {
   5209                                   if (((word >> 21) & 0x1) == 0)
   5210                                     {
   5211                                       if (((word >> 30) & 0x1) == 0)
   5212                                         {
   5213                                           if (((word >> 31) & 0x1) == 0)
   5214                                             {
   5215                                               /* 33222222222211111111110000000000
   5216                                                  10987654321098765432109876543210
   5217                                                  000001x0xx0xxxxx010xxxxxxxxxxxxx
   5218                                                  mla.  */
   5219                                               return 1743;
   5220                                             }
   5221                                           else
   5222                                             {
   5223                                               if (((word >> 23) & 0x1) == 0)
   5224                                                 {
   5225                                                   /* 33222222222211111111110000000000
   5226                                                      10987654321098765432109876543210
   5227                                                      100001x00x0xxxxx010xxxxxxxxxxxxx
   5228                                                      ld1b.  */
   5229                                                   return 1504;
   5230                                                 }
   5231                                               else
   5232                                                 {
   5233                                                   /* 33222222222211111111110000000000
   5234                                                      10987654321098765432109876543210
   5235                                                      100001x01x0xxxxx010xxxxxxxxxxxxx
   5236                                                      ld1h.  */
   5237                                                   return 1524;
   5238                                                 }
   5239                                             }
   5240                                         }
   5241                                       else
   5242                                         {
   5243                                           if (((word >> 31) & 0x1) == 0)
   5244                                             {
   5245                                               if (((word >> 10) & 0x1) == 0)
   5246                                                 {
   5247                                                   if (((word >> 11) & 0x1) == 0)
   5248                                                     {
   5249                                                       if (((word >> 12) & 0x1) == 0)
   5250                                                         {
   5251                                                           /* 33222222222211111111110000000000
   5252                                                              10987654321098765432109876543210
   5253                                                              010001x0xx0xxxxx010000xxxxxxxxxx
   5254                                                              smlalb.  */
   5255                                                           return 2147;
   5256                                                         }
   5257                                                       else
   5258                                                         {
   5259                                                           /* 33222222222211111111110000000000
   5260                                                              10987654321098765432109876543210
   5261                                                              010001x0xx0xxxxx010100xxxxxxxxxx
   5262                                                              smlslb.  */
   5263                                                           return 2153;
   5264                                                         }
   5265                                                     }
   5266                                                   else
   5267                                                     {
   5268                                                       if (((word >> 12) & 0x1) == 0)
   5269                                                         {
   5270                                                           /* 33222222222211111111110000000000
   5271                                                              10987654321098765432109876543210
   5272                                                              010001x0xx0xxxxx010010xxxxxxxxxx
   5273                                                              umlalb.  */
   5274                                                           return 2272;
   5275                                                         }
   5276                                                       else
   5277                                                         {
   5278                                                           /* 33222222222211111111110000000000
   5279                                                              10987654321098765432109876543210
   5280                                                              010001x0xx0xxxxx010110xxxxxxxxxx
   5281                                                              umlslb.  */
   5282                                                           return 2278;
   5283                                                         }
   5284                                                     }
   5285                                                 }
   5286                                               else
   5287                                                 {
   5288                                                   if (((word >> 11) & 0x1) == 0)
   5289                                                     {
   5290                                                       if (((word >> 12) & 0x1) == 0)
   5291                                                         {
   5292                                                           /* 33222222222211111111110000000000
   5293                                                              10987654321098765432109876543210
   5294                                                              010001x0xx0xxxxx010001xxxxxxxxxx
   5295                                                              smlalt.  */
   5296                                                           return 2150;
   5297                                                         }
   5298                                                       else
   5299                                                         {
   5300                                                           /* 33222222222211111111110000000000
   5301                                                              10987654321098765432109876543210
   5302                                                              010001x0xx0xxxxx010101xxxxxxxxxx
   5303                                                              smlslt.  */
   5304                                                           return 2156;
   5305                                                         }
   5306                                                     }
   5307                                                   else
   5308                                                     {
   5309                                                       if (((word >> 12) & 0x1) == 0)
   5310                                                         {
   5311                                                           /* 33222222222211111111110000000000
   5312                                                              10987654321098765432109876543210
   5313                                                              010001x0xx0xxxxx010011xxxxxxxxxx
   5314                                                              umlalt.  */
   5315                                                           return 2275;
   5316                                                         }
   5317                                                       else
   5318                                                         {
   5319                                                           /* 33222222222211111111110000000000
   5320                                                              10987654321098765432109876543210
   5321                                                              010001x0xx0xxxxx010111xxxxxxxxxx
   5322                                                              umlslt.  */
   5323                                                           return 2281;
   5324                                                         }
   5325                                                     }
   5326                                                 }
   5327                                             }
   5328                                           else
   5329                                             {
   5330                                               if (((word >> 23) & 0x1) == 0)
   5331                                                 {
   5332                                                   /* 33222222222211111111110000000000
   5333                                                      10987654321098765432109876543210
   5334                                                      110001x00x0xxxxx010xxxxxxxxxxxxx
   5335                                                      ld1b.  */
   5336                                                   return 1509;
   5337                                                 }
   5338                                               else
   5339                                                 {
   5340                                                   /* 33222222222211111111110000000000
   5341                                                      10987654321098765432109876543210
   5342                                                      110001x01x0xxxxx010xxxxxxxxxxxxx
   5343                                                      ld1h.  */
   5344                                                   return 1529;
   5345                                                 }
   5346                                             }
   5347                                         }
   5348                                     }
   5349                                   else
   5350                                     {
   5351                                       if (((word >> 30) & 0x1) == 0)
   5352                                         {
   5353                                           if (((word >> 31) & 0x1) == 0)
   5354                                             {
   5355                                               if (((word >> 11) & 0x1) == 0)
   5356                                                 {
   5357                                                   if (((word >> 12) & 0x1) == 0)
   5358                                                     {
   5359                                                       if (((word >> 10) & 0x1) == 0)
   5360                                                         {
   5361                                                           /* 33222222222211111111110000000000
   5362                                                              10987654321098765432109876543210
   5363                                                              000001x0xx1xxxxx010000xxxxxxxxxx
   5364                                                              index.  */
   5365                                                           return 1495;
   5366                                                         }
   5367                                                       else
   5368                                                         {
   5369                                                           /* 33222222222211111111110000000000
   5370                                                              10987654321098765432109876543210
   5371                                                              000001x0xx1xxxxx010001xxxxxxxxxx
   5372                                                              index.  */
   5373                                                           return 1496;
   5374                                                         }
   5375                                                     }
   5376                                                   else
   5377                                                     {
   5378                                                       if (((word >> 22) & 0x1) == 0)
   5379                                                         {
   5380                                                           if (((word >> 23) & 0x1) == 0)
   5381                                                             {
   5382                                                               /* 33222222222211111111110000000000
   5383                                                                  10987654321098765432109876543210
   5384                                                                  000001x0001xxxxx01010xxxxxxxxxxx
   5385                                                                  addvl.  */
   5386                                                               return 1282;
   5387                                                             }
   5388                                                           else
   5389                                                             {
   5390                                                               /* 33222222222211111111110000000000
   5391                                                                  10987654321098765432109876543210
   5392                                                                  000001x0101xxxxx01010xxxxxxxxxxx
   5393                                                                  rdvl.  */
   5394                                                               return 1804;
   5395                                                             }
   5396                                                         }
   5397                                                       else
   5398                                                         {
   5399                                                           /* 33222222222211111111110000000000
   5400                                                              10987654321098765432109876543210
   5401                                                              000001x0x11xxxxx01010xxxxxxxxxxx
   5402                                                              addpl.  */
   5403                                                           return 1281;
   5404                                                         }
   5405                                                     }
   5406                                                 }
   5407                                               else
   5408                                                 {
   5409                                                   if (((word >> 10) & 0x1) == 0)
   5410                                                     {
   5411                                                       /* 33222222222211111111110000000000
   5412                                                          10987654321098765432109876543210
   5413                                                          000001x0xx1xxxxx010x10xxxxxxxxxx
   5414                                                          index.  */
   5415                                                       return 1497;
   5416                                                     }
   5417                                                   else
   5418                                                     {
   5419                                                       /* 33222222222211111111110000000000
   5420                                                          10987654321098765432109876543210
   5421                                                          000001x0xx1xxxxx010x11xxxxxxxxxx
   5422                                                          index.  */
   5423                                                       return 1494;
   5424                                                     }
   5425                                                 }
   5426                                             }
   5427                                           else
   5428                                             {
   5429                                               if (((word >> 23) & 0x1) == 0)
   5430                                                 {
   5431                                                   /* 33222222222211111111110000000000
   5432                                                      10987654321098765432109876543210
   5433                                                      100001x00x1xxxxx010xxxxxxxxxxxxx
   5434                                                      prfw.  */
   5435                                                   return 1788;
   5436                                                 }
   5437                                               else
   5438                                                 {
   5439                                                   /* 33222222222211111111110000000000
   5440                                                      10987654321098765432109876543210
   5441                                                      100001x01x1xxxxx010xxxxxxxxxxxxx
   5442                                                      ld1h.  */
   5443                                                   return 1525;
   5444                                                 }
   5445                                             }
   5446                                         }
   5447                                       else
   5448                                         {
   5449                                           if (((word >> 23) & 0x1) == 0)
   5450                                             {
   5451                                               /* 33222222222211111111110000000000
   5452                                                  10987654321098765432109876543210
   5453                                                  x10001x00x1xxxxx010xxxxxxxxxxxxx
   5454                                                  prfw.  */
   5455                                               return 1790;
   5456                                             }
   5457                                           else
   5458                                             {
   5459                                               if (((word >> 31) & 0x1) == 0)
   5460                                                 {
   5461                                                   if (((word >> 22) & 0x1) == 0)
   5462                                                     {
   5463                                                       /* 33222222222211111111110000000000
   5464                                                          10987654321098765432109876543210
   5465                                                          010001x0101xxxxx010xxxxxxxxxxxxx
   5466                                                          cdot.  */
   5467                                                       return 2062;
   5468                                                     }
   5469                                                   else
   5470                                                     {
   5471                                                       /* 33222222222211111111110000000000
   5472                                                          10987654321098765432109876543210
   5473                                                          010001x0111xxxxx010xxxxxxxxxxxxx
   5474                                                          cdot.  */
   5475                                                       return 2061;
   5476                                                     }
   5477                                                 }
   5478                                               else
   5479                                                 {
   5480                                                   /* 33222222222211111111110000000000
   5481                                                      10987654321098765432109876543210
   5482                                                      110001x01x1xxxxx010xxxxxxxxxxxxx
   5483                                                      ld1h.  */
   5484                                                   return 1530;
   5485                                                 }
   5486                                             }
   5487                                         }
   5488                                     }
   5489                                 }
   5490                               else
   5491                                 {
   5492                                   if (((word >> 30) & 0x1) == 0)
   5493                                     {
   5494                                       if (((word >> 31) & 0x1) == 0)
   5495                                         {
   5496                                           if (((word >> 21) & 0x1) == 0)
   5497                                             {
   5498                                               /* 33222222222211111111110000000000
   5499                                                  10987654321098765432109876543210
   5500                                                  000001x0xx0xxxxx110xxxxxxxxxxxxx
   5501                                                  mad.  */
   5502                                               return 1742;
   5503                                             }
   5504                                           else
   5505                                             {
   5506                                               if (((word >> 10) & 0x1) == 0)
   5507                                                 {
   5508                                                   if (((word >> 11) & 0x1) == 0)
   5509                                                     {
   5510                                                       if (((word >> 20) & 0x1) == 0)
   5511                                                         {
   5512                                                           if (((word >> 22) & 0x1) == 0)
   5513                                                             {
   5514                                                               /* 33222222222211111111110000000000
   5515                                                                  10987654321098765432109876543210
   5516                                                                  000001x0x010xxxx110x00xxxxxxxxxx
   5517                                                                  sqincw.  */
   5518                                                               return 1862;
   5519                                                             }
   5520                                                           else
   5521                                                             {
   5522                                                               if (((word >> 23) & 0x1) == 0)
   5523                                                                 {
   5524                                                                   /* 33222222222211111111110000000000
   5525                                                                      10987654321098765432109876543210
   5526                                                                      000001x00110xxxx110x00xxxxxxxxxx
   5527                                                                      sqinch.  */
   5528                                                                   return 1856;
   5529                                                                 }
   5530                                                               else
   5531                                                                 {
   5532                                                                   /* 33222222222211111111110000000000
   5533                                                                      10987654321098765432109876543210
   5534                                                                      000001x01110xxxx110x00xxxxxxxxxx
   5535                                                                      sqincd.  */
   5536                                                                   return 1853;
   5537                                                                 }
   5538                                                             }
   5539                                                         }
   5540                                                       else
   5541                                                         {
   5542                                                           if (((word >> 22) & 0x1) == 0)
   5543                                                             {
   5544                                                               /* 33222222222211111111110000000000
   5545                                                                  10987654321098765432109876543210
   5546                                                                  000001x0x011xxxx110x00xxxxxxxxxx
   5547                                                                  incw.  */
   5548                                                               return 1492;
   5549                                                             }
   5550                                                           else
   5551                                                             {
   5552                                                               if (((word >> 23) & 0x1) == 0)
   5553                                                                 {
   5554                                                                   /* 33222222222211111111110000000000
   5555                                                                      10987654321098765432109876543210
   5556                                                                      000001x00111xxxx110x00xxxxxxxxxx
   5557                                                                      inch.  */
   5558                                                                   return 1488;
   5559                                                                 }
   5560                                                               else
   5561                                                                 {
   5562                                                                   /* 33222222222211111111110000000000
   5563                                                                      10987654321098765432109876543210
   5564                                                                      000001x01111xxxx110x00xxxxxxxxxx
   5565                                                                      incd.  */
   5566                                                                   return 1486;
   5567                                                                 }
   5568                                                             }
   5569                                                         }
   5570                                                     }
   5571                                                   else
   5572                                                     {
   5573                                                       if (((word >> 22) & 0x1) == 0)
   5574                                                         {
   5575                                                           /* 33222222222211111111110000000000
   5576                                                              10987654321098765432109876543210
   5577                                                              000001x0x01xxxxx110x10xxxxxxxxxx
   5578                                                              sqdecw.  */
   5579                                                           return 1848;
   5580                                                         }
   5581                                                       else
   5582                                                         {
   5583                                                           if (((word >> 23) & 0x1) == 0)
   5584                                                             {
   5585                                                               /* 33222222222211111111110000000000
   5586                                                                  10987654321098765432109876543210
   5587                                                                  000001x0011xxxxx110x10xxxxxxxxxx
   5588                                                                  sqdech.  */
   5589                                                               return 1842;
   5590                                                             }
   5591                                                           else
   5592                                                             {
   5593                                                               /* 33222222222211111111110000000000
   5594                                                                  10987654321098765432109876543210
   5595                                                                  000001x0111xxxxx110x10xxxxxxxxxx
   5596                                                                  sqdecd.  */
   5597                                                               return 1839;
   5598                                                             }
   5599                                                         }
   5600                                                     }
   5601                                                 }
   5602                                               else
   5603                                                 {
   5604                                                   if (((word >> 11) & 0x1) == 0)
   5605                                                     {
   5606                                                       if (((word >> 20) & 0x1) == 0)
   5607                                                         {
   5608                                                           if (((word >> 22) & 0x1) == 0)
   5609                                                             {
   5610                                                               /* 33222222222211111111110000000000
   5611                                                                  10987654321098765432109876543210
   5612                                                                  000001x0x010xxxx110x01xxxxxxxxxx
   5613                                                                  uqincw.  */
   5614                                                               return 2010;
   5615                                                             }
   5616                                                           else
   5617                                                             {
   5618                                                               if (((word >> 23) & 0x1) == 0)
   5619                                                                 {
   5620                                                                   /* 33222222222211111111110000000000
   5621                                                                      10987654321098765432109876543210
   5622                                                                      000001x00110xxxx110x01xxxxxxxxxx
   5623                                                                      uqinch.  */
   5624                                                                   return 2004;
   5625                                                                 }
   5626                                                               else
   5627                                                                 {
   5628                                                                   /* 33222222222211111111110000000000
   5629                                                                      10987654321098765432109876543210
   5630                                                                      000001x01110xxxx110x01xxxxxxxxxx
   5631                                                                      uqincd.  */
   5632                                                                   return 2001;
   5633                                                                 }
   5634                                                             }
   5635                                                         }
   5636                                                       else
   5637                                                         {
   5638                                                           if (((word >> 22) & 0x1) == 0)
   5639                                                             {
   5640                                                               /* 33222222222211111111110000000000
   5641                                                                  10987654321098765432109876543210
   5642                                                                  000001x0x011xxxx110x01xxxxxxxxxx
   5643                                                                  decw.  */
   5644                                                               return 1367;
   5645                                                             }
   5646                                                           else
   5647                                                             {
   5648                                                               if (((word >> 23) & 0x1) == 0)
   5649                                                                 {
   5650                                                                   /* 33222222222211111111110000000000
   5651                                                                      10987654321098765432109876543210
   5652                                                                      000001x00111xxxx110x01xxxxxxxxxx
   5653                                                                      dech.  */
   5654                                                                   return 1363;
   5655                                                                 }
   5656                                                               else
   5657                                                                 {
   5658                                                                   /* 33222222222211111111110000000000
   5659                                                                      10987654321098765432109876543210
   5660                                                                      000001x01111xxxx110x01xxxxxxxxxx
   5661                                                                      decd.  */
   5662                                                                   return 1361;
   5663                                                                 }
   5664                                                             }
   5665                                                         }
   5666                                                     }
   5667                                                   else
   5668                                                     {
   5669                                                       if (((word >> 22) & 0x1) == 0)
   5670                                                         {
   5671                                                           /* 33222222222211111111110000000000
   5672                                                              10987654321098765432109876543210
   5673                                                              000001x0x01xxxxx110x11xxxxxxxxxx
   5674                                                              uqdecw.  */
   5675                                                           return 1996;
   5676                                                         }
   5677                                                       else
   5678                                                         {
   5679                                                           if (((word >> 23) & 0x1) == 0)
   5680                                                             {
   5681                                                               /* 33222222222211111111110000000000
   5682                                                                  10987654321098765432109876543210
   5683                                                                  000001x0011xxxxx110x11xxxxxxxxxx
   5684                                                                  uqdech.  */
   5685                                                               return 1990;
   5686                                                             }
   5687                                                           else
   5688                                                             {
   5689                                                               /* 33222222222211111111110000000000
   5690                                                                  10987654321098765432109876543210
   5691                                                                  000001x0111xxxxx110x11xxxxxxxxxx
   5692                                                                  uqdecd.  */
   5693                                                               return 1987;
   5694                                                             }
   5695                                                         }
   5696                                                     }
   5697                                                 }
   5698                                             }
   5699                                         }
   5700                                       else
   5701                                         {
   5702                                           if (((word >> 22) & 0x1) == 0)
   5703                                             {
   5704                                               if (((word >> 21) & 0x1) == 0)
   5705                                                 {
   5706                                                   if (((word >> 23) & 0x1) == 0)
   5707                                                     {
   5708                                                       /* 33222222222211111111110000000000
   5709                                                          10987654321098765432109876543210
   5710                                                          100001x0000xxxxx110xxxxxxxxxxxxx
   5711                                                          prfb.  */
   5712                                                       return 1767;
   5713                                                     }
   5714                                                   else
   5715                                                     {
   5716                                                       /* 33222222222211111111110000000000
   5717                                                          10987654321098765432109876543210
   5718                                                          100001x0100xxxxx110xxxxxxxxxxxxx
   5719                                                          prfh.  */
   5720                                                       return 1782;
   5721                                                     }
   5722                                                 }
   5723                                               else
   5724                                                 {
   5725                                                   if (((word >> 23) & 0x1) == 0)
   5726                                                     {
   5727                                                       /* 33222222222211111111110000000000
   5728                                                          10987654321098765432109876543210
   5729                                                          100001x0001xxxxx110xxxxxxxxxxxxx
   5730                                                          ld1b.  */
   5731                                                       return 1511;
   5732                                                     }
   5733                                                   else
   5734                                                     {
   5735                                                       /* 33222222222211111111110000000000
   5736                                                          10987654321098765432109876543210
   5737                                                          100001x0101xxxxx110xxxxxxxxxxxxx
   5738                                                          ld1h.  */
   5739                                                       return 1533;
   5740                                                     }
   5741                                                 }
   5742                                             }
   5743                                           else
   5744                                             {
   5745                                               if (((word >> 23) & 0x1) == 0)
   5746                                                 {
   5747                                                   /* 33222222222211111111110000000000
   5748                                                      10987654321098765432109876543210
   5749                                                      100001x001xxxxxx110xxxxxxxxxxxxx
   5750                                                      ld1rb.  */
   5751                                                   return 1540;
   5752                                                 }
   5753                                               else
   5754                                                 {
   5755                                                   /* 33222222222211111111110000000000
   5756                                                      10987654321098765432109876543210
   5757                                                      100001x011xxxxxx110xxxxxxxxxxxxx
   5758                                                      ld1rh.  */
   5759                                                   return 1544;
   5760                                                 }
   5761                                             }
   5762                                         }
   5763                                     }
   5764                                   else
   5765                                     {
   5766                                       if (((word >> 21) & 0x1) == 0)
   5767                                         {
   5768                                           if (((word >> 22) & 0x1) == 0)
   5769                                             {
   5770                                               if (((word >> 23) & 0x1) == 0)
   5771                                                 {
   5772                                                   /* 33222222222211111111110000000000
   5773                                                      10987654321098765432109876543210
   5774                                                      x10001x0000xxxxx110xxxxxxxxxxxxx
   5775                                                      ldnt1b.  */
   5776                                                   return 2093;
   5777                                                 }
   5778                                               else
   5779                                                 {
   5780                                                   /* 33222222222211111111110000000000
   5781                                                      10987654321098765432109876543210
   5782                                                      x10001x0100xxxxx110xxxxxxxxxxxxx
   5783                                                      ldnt1h.  */
   5784                                                   return 2096;
   5785                                                 }
   5786                                             }
   5787                                           else
   5788                                             {
   5789                                               if (((word >> 23) & 0x1) == 0)
   5790                                                 {
   5791                                                   /* 33222222222211111111110000000000
   5792                                                      10987654321098765432109876543210
   5793                                                      x10001x0010xxxxx110xxxxxxxxxxxxx
   5794                                                      ld1b.  */
   5795                                                   return 1510;
   5796                                                 }
   5797                                               else
   5798                                                 {
   5799                                                   /* 33222222222211111111110000000000
   5800                                                      10987654321098765432109876543210
   5801                                                      x10001x0110xxxxx110xxxxxxxxxxxxx
   5802                                                      ld1h.  */
   5803                                                   return 1531;
   5804                                                 }
   5805                                             }
   5806                                         }
   5807                                       else
   5808                                         {
   5809                                           if (((word >> 22) & 0x1) == 0)
   5810                                             {
   5811                                               if (((word >> 23) & 0x1) == 0)
   5812                                                 {
   5813                                                   /* 33222222222211111111110000000000
   5814                                                      10987654321098765432109876543210
   5815                                                      x10001x0001xxxxx110xxxxxxxxxxxxx
   5816                                                      ld1b.  */
   5817                                                   return 1516;
   5818                                                 }
   5819                                               else
   5820                                                 {
   5821                                                   if (((word >> 31) & 0x1) == 0)
   5822                                                     {
   5823                                                       if (((word >> 10) & 0x1) == 0)
   5824                                                         {
   5825                                                           if (((word >> 12) & 0x1) == 0)
   5826                                                             {
   5827                                                               /* 33222222222211111111110000000000
   5828                                                                  10987654321098765432109876543210
   5829                                                                  010001x0101xxxxx1100x0xxxxxxxxxx
   5830                                                                  smullb.  */
   5831                                                               return 2158;
   5832                                                             }
   5833                                                           else
   5834                                                             {
   5835                                                               /* 33222222222211111111110000000000
   5836                                                                  10987654321098765432109876543210
   5837                                                                  010001x0101xxxxx1101x0xxxxxxxxxx
   5838                                                                  umullb.  */
   5839                                                               return 2283;
   5840                                                             }
   5841                                                         }
   5842                                                       else
   5843                                                         {
   5844                                                           if (((word >> 12) & 0x1) == 0)
   5845                                                             {
   5846                                                               /* 33222222222211111111110000000000
   5847                                                                  10987654321098765432109876543210
   5848                                                                  010001x0101xxxxx1100x1xxxxxxxxxx
   5849                                                                  smullt.  */
   5850                                                               return 2161;
   5851                                                             }
   5852                                                           else
   5853                                                             {
   5854                                                               /* 33222222222211111111110000000000
   5855                                                                  10987654321098765432109876543210
   5856                                                                  010001x0101xxxxx1101x1xxxxxxxxxx
   5857                                                                  umullt.  */
   5858                                                               return 2286;
   5859                                                             }
   5860                                                         }
   5861                                                     }
   5862                                                   else
   5863                                                     {
   5864                                                       /* 33222222222211111111110000000000
   5865                                                          10987654321098765432109876543210
   5866                                                          110001x0101xxxxx110xxxxxxxxxxxxx
   5867                                                          ld1h.  */
   5868                                                       return 1537;
   5869                                                     }
   5870                                                 }
   5871                                             }
   5872                                           else
   5873                                             {
   5874                                               if (((word >> 23) & 0x1) == 0)
   5875                                                 {
   5876                                                   /* 33222222222211111111110000000000
   5877                                                      10987654321098765432109876543210
   5878                                                      x10001x0011xxxxx110xxxxxxxxxxxxx
   5879                                                      prfw.  */
   5880                                                   return 1791;
   5881                                                 }
   5882                                               else
   5883                                                 {
   5884                                                   if (((word >> 31) & 0x1) == 0)
   5885                                                     {
   5886                                                       if (((word >> 10) & 0x1) == 0)
   5887                                                         {
   5888                                                           if (((word >> 12) & 0x1) == 0)
   5889                                                             {
   5890                                                               /* 33222222222211111111110000000000
   5891                                                                  10987654321098765432109876543210
   5892                                                                  010001x0111xxxxx1100x0xxxxxxxxxx
   5893                                                                  smullb.  */
   5894                                                               return 2159;
   5895                                                             }
   5896                                                           else
   5897                                                             {
   5898                                                               /* 33222222222211111111110000000000
   5899                                                                  10987654321098765432109876543210
   5900                                                                  010001x0111xxxxx1101x0xxxxxxxxxx
   5901                                                                  umullb.  */
   5902                                                               return 2284;
   5903                                                             }
   5904                                                         }
   5905                                                       else
   5906                                                         {
   5907                                                           if (((word >> 12) & 0x1) == 0)
   5908                                                             {
   5909                                                               /* 33222222222211111111110000000000
   5910                                                                  10987654321098765432109876543210
   5911                                                                  010001x0111xxxxx1100x1xxxxxxxxxx
   5912                                                                  smullt.  */
   5913                                                               return 2162;
   5914                                                             }
   5915                                                           else
   5916                                                             {
   5917                                                               /* 33222222222211111111110000000000
   5918                                                                  10987654321098765432109876543210
   5919                                                                  010001x0111xxxxx1101x1xxxxxxxxxx
   5920                                                                  umullt.  */
   5921                                                               return 2287;
   5922                                                             }
   5923                                                         }
   5924                                                     }
   5925                                                   else
   5926                                                     {
   5927                                                       /* 33222222222211111111110000000000
   5928                                                          10987654321098765432109876543210
   5929                                                          110001x0111xxxxx110xxxxxxxxxxxxx
   5930                                                          ld1h.  */
   5931                                                       return 1532;
   5932                                                     }
   5933                                                 }
   5934                                             }
   5935                                         }
   5936                                     }
   5937                                 }
   5938                             }
   5939                         }
   5940                       else
   5941                         {
   5942                           if (((word >> 14) & 0x1) == 0)
   5943                             {
   5944                               if (((word >> 15) & 0x1) == 0)
   5945                                 {
   5946                                   if (((word >> 21) & 0x1) == 0)
   5947                                     {
   5948                                       if (((word >> 30) & 0x1) == 0)
   5949                                         {
   5950                                           if (((word >> 31) & 0x1) == 0)
   5951                                             {
   5952                                               if (((word >> 17) & 0x1) == 0)
   5953                                                 {
   5954                                                   if (((word >> 19) & 0x1) == 0)
   5955                                                     {
   5956                                                       if (((word >> 20) & 0x1) == 0)
   5957                                                         {
   5958                                                           if (((word >> 16) & 0x1) == 0)
   5959                                                             {
   5960                                                               /* 33222222222211111111110000000000
   5961                                                                  10987654321098765432109876543210
   5962                                                                  000001x0xx000x00001xxxxxxxxxxxxx
   5963                                                                  saddv.  */
   5964                                                               return 1811;
   5965                                                             }
   5966                                                           else
   5967                                                             {
   5968                                                               /* 33222222222211111111110000000000
   5969                                                                  10987654321098765432109876543210
   5970                                                                  000001x0xx000x01001xxxxxxxxxxxxx
   5971                                                                  uaddv.  */
   5972                                                               return 1963;
   5973                                                             }
   5974                                                         }
   5975                                                       else
   5976                                                         {
   5977                                                           /* 33222222222211111111110000000000
   5978                                                              10987654321098765432109876543210
   5979                                                              000001x0xx010x0x001xxxxxxxxxxxxx
   5980                                                              movprfx.  */
   5981                                                           return 1746;
   5982                                                         }
   5983                                                     }
   5984                                                   else
   5985                                                     {
   5986                                                       if (((word >> 16) & 0x1) == 0)
   5987                                                         {
   5988                                                           if (((word >> 20) & 0x1) == 0)
   5989                                                             {
   5990                                                               /* 33222222222211111111110000000000
   5991                                                                  10987654321098765432109876543210
   5992                                                                  000001x0xx001x00001xxxxxxxxxxxxx
   5993                                                                  smaxv.  */
   5994                                                               return 1829;
   5995                                                             }
   5996                                                           else
   5997                                                             {
   5998                                                               /* 33222222222211111111110000000000
   5999                                                                  10987654321098765432109876543210
   6000                                                                  000001x0xx011x00001xxxxxxxxxxxxx
   6001                                                                  orv.  */
   6002                                                               return 1763;
   6003                                                             }
   6004                                                         }
   6005                                                       else
   6006                                                         {
   6007                                                           if (((word >> 20) & 0x1) == 0)
   6008                                                             {
   6009                                                               /* 33222222222211111111110000000000
   6010                                                                  10987654321098765432109876543210
   6011                                                                  000001x0xx001x01001xxxxxxxxxxxxx
   6012                                                                  umaxv.  */
   6013                                                               return 1978;
   6014                                                             }
   6015                                                           else
   6016                                                             {
   6017                                                               /* 33222222222211111111110000000000
   6018                                                                  10987654321098765432109876543210
   6019                                                                  000001x0xx011x01001xxxxxxxxxxxxx
   6020                                                                  eorv.  */
   6021                                                               return 1378;
   6022                                                             }
   6023                                                         }
   6024                                                     }
   6025                                                 }
   6026                                               else
   6027                                                 {
   6028                                                   if (((word >> 16) & 0x1) == 0)
   6029                                                     {
   6030                                                       if (((word >> 20) & 0x1) == 0)
   6031                                                         {
   6032                                                           /* 33222222222211111111110000000000
   6033                                                              10987654321098765432109876543210
   6034                                                              000001x0xx00xx10001xxxxxxxxxxxxx
   6035                                                              sminv.  */
   6036                                                           return 1832;
   6037                                                         }
   6038                                                       else
   6039                                                         {
   6040                                                           /* 33222222222211111111110000000000
   6041                                                              10987654321098765432109876543210
   6042                                                              000001x0xx01xx10001xxxxxxxxxxxxx
   6043                                                              andv.  */
   6044                                                           return 1291;
   6045                                                         }
   6046                                                     }
   6047                                                   else
   6048                                                     {
   6049                                                       /* 33222222222211111111110000000000
   6050                                                          10987654321098765432109876543210
   6051                                                          000001x0xx0xxx11001xxxxxxxxxxxxx
   6052                                                          uminv.  */
   6053                                                       return 1981;
   6054                                                     }
   6055                                                 }
   6056                                             }
   6057                                           else
   6058                                             {
   6059                                               if (((word >> 23) & 0x1) == 0)
   6060                                                 {
   6061                                                   /* 33222222222211111111110000000000
   6062                                                      10987654321098765432109876543210
   6063                                                      100001x00x0xxxxx001xxxxxxxxxxxxx
   6064                                                      ldff1sb.  */
   6065                                                   return 1662;
   6066                                                 }
   6067                                               else
   6068                                                 {
   6069                                                   /* 33222222222211111111110000000000
   6070                                                      10987654321098765432109876543210
   6071                                                      100001x01x0xxxxx001xxxxxxxxxxxxx
   6072                                                      ldff1sh.  */
   6073                                                   return 1673;
   6074                                                 }
   6075                                             }
   6076                                         }
   6077                                       else
   6078                                         {
   6079                                           if (((word >> 31) & 0x1) == 0)
   6080                                             {
   6081                                               if (((word >> 12) & 0x1) == 0)
   6082                                                 {
   6083                                                   /* 33222222222211111111110000000000
   6084                                                      10987654321098765432109876543210
   6085                                                      010001x0xx0xxxxx0010xxxxxxxxxxxx
   6086                                                      cmla.  */
   6087                                                   return 2063;
   6088                                                 }
   6089                                               else
   6090                                                 {
   6091                                                   /* 33222222222211111111110000000000
   6092                                                      10987654321098765432109876543210
   6093                                                      010001x0xx0xxxxx0011xxxxxxxxxxxx
   6094                                                      sqrdcmlah.  */
   6095                                                   return 2195;
   6096                                                 }
   6097                                             }
   6098                                           else
   6099                                             {
   6100                                               if (((word >> 23) & 0x1) == 0)
   6101                                                 {
   6102                                                   /* 33222222222211111111110000000000
   6103                                                      10987654321098765432109876543210
   6104                                                      110001x00x0xxxxx001xxxxxxxxxxxxx
   6105                                                      ldff1sb.  */
   6106                                                   return 1669;
   6107                                                 }
   6108                                               else
   6109                                                 {
   6110                                                   /* 33222222222211111111110000000000
   6111                                                      10987654321098765432109876543210
   6112                                                      110001x01x0xxxxx001xxxxxxxxxxxxx
   6113                                                      ldff1sh.  */
   6114                                                   return 1679;
   6115                                                 }
   6116                                             }
   6117                                         }
   6118                                     }
   6119                                   else
   6120                                     {
   6121                                       if (((word >> 30) & 0x1) == 0)
   6122                                         {
   6123                                           if (((word >> 31) & 0x1) == 0)
   6124                                             {
   6125                                               if (((word >> 10) & 0x1) == 0)
   6126                                                 {
   6127                                                   if (((word >> 11) & 0x1) == 0)
   6128                                                     {
   6129                                                       if (((word >> 22) & 0x1) == 0)
   6130                                                         {
   6131                                                           if (((word >> 23) & 0x1) == 0)
   6132                                                             {
   6133                                                               /* 33222222222211111111110000000000
   6134                                                                  10987654321098765432109876543210
   6135                                                                  000001x0001xxxxx001x00xxxxxxxxxx
   6136                                                                  and.  */
   6137                                                               return 1286;
   6138                                                             }
   6139                                                           else
   6140                                                             {
   6141                                                               /* 33222222222211111111110000000000
   6142                                                                  10987654321098765432109876543210
   6143                                                                  000001x0101xxxxx001x00xxxxxxxxxx
   6144                                                                  eor.  */
   6145                                                               return 1373;
   6146                                                             }
   6147                                                         }
   6148                                                       else
   6149                                                         {
   6150                                                           if (((word >> 23) & 0x1) == 0)
   6151                                                             {
   6152                                                               /* 33222222222211111111110000000000
   6153                                                                  10987654321098765432109876543210
   6154                                                                  000001x0011xxxxx001x00xxxxxxxxxx
   6155                                                                  orr.  */
   6156                                                               return 1758;
   6157                                                             }
   6158                                                           else
   6159                                                             {
   6160                                                               /* 33222222222211111111110000000000
   6161                                                                  10987654321098765432109876543210
   6162                                                                  000001x0111xxxxx001x00xxxxxxxxxx
   6163                                                                  bic.  */
   6164                                                               return 1299;
   6165                                                             }
   6166                                                         }
   6167                                                     }
   6168                                                   else
   6169                                                     {
   6170                                                       if (((word >> 22) & 0x1) == 0)
   6171                                                         {
   6172                                                           /* 33222222222211111111110000000000
   6173                                                              10987654321098765432109876543210
   6174                                                              000001x0x01xxxxx001x10xxxxxxxxxx
   6175                                                              eor3.  */
   6176                                                           return 2066;
   6177                                                         }
   6178                                                       else
   6179                                                         {
   6180                                                           /* 33222222222211111111110000000000
   6181                                                              10987654321098765432109876543210
   6182                                                              000001x0x11xxxxx001x10xxxxxxxxxx
   6183                                                              bcax.  */
   6184                                                           return 2055;
   6185                                                         }
   6186                                                     }
   6187                                                 }
   6188                                               else
   6189                                                 {
   6190                                                   if (((word >> 11) & 0x1) == 0)
   6191                                                     {
   6192                                                       /* 33222222222211111111110000000000
   6193                                                          10987654321098765432109876543210
   6194                                                          000001x0xx1xxxxx001x01xxxxxxxxxx
   6195                                                          xar.  */
   6196                                                       return 2328;
   6197                                                     }
   6198                                                   else
   6199                                                     {
   6200                                                       if (((word >> 22) & 0x1) == 0)
   6201                                                         {
   6202                                                           if (((word >> 23) & 0x1) == 0)
   6203                                                             {
   6204                                                               /* 33222222222211111111110000000000
   6205                                                                  10987654321098765432109876543210
   6206                                                                  000001x0001xxxxx001x11xxxxxxxxxx
   6207                                                                  bsl.  */
   6208                                                               return 2056;
   6209                                                             }
   6210                                                           else
   6211                                                             {
   6212                                                               /* 33222222222211111111110000000000
   6213                                                                  10987654321098765432109876543210
   6214                                                                  000001x0101xxxxx001x11xxxxxxxxxx
   6215                                                                  bsl2n.  */
   6216                                                               return 2058;
   6217                                                             }
   6218                                                         }
   6219                                                       else
   6220                                                         {
   6221                                                           if (((word >> 23) & 0x1) == 0)
   6222                                                             {
   6223                                                               /* 33222222222211111111110000000000
   6224                                                                  10987654321098765432109876543210
   6225                                                                  000001x0011xxxxx001x11xxxxxxxxxx
   6226                                                                  bsl1n.  */
   6227                                                               return 2057;
   6228                                                             }
   6229                                                           else
   6230                                                             {
   6231                                                               /* 33222222222211111111110000000000
   6232                                                                  10987654321098765432109876543210
   6233                                                                  000001x0111xxxxx001x11xxxxxxxxxx
   6234                                                                  nbsl.  */
   6235                                                               return 2113;
   6236                                                             }
   6237                                                         }
   6238                                                     }
   6239                                                 }
   6240                                             }
   6241                                           else
   6242                                             {
   6243                                               if (((word >> 23) & 0x1) == 0)
   6244                                                 {
   6245                                                   /* 33222222222211111111110000000000
   6246                                                      10987654321098765432109876543210
   6247                                                      100001x00x1xxxxx001xxxxxxxxxxxxx
   6248                                                      prfh.  */
   6249                                                   return 1781;
   6250                                                 }
   6251                                               else
   6252                                                 {
   6253                                                   /* 33222222222211111111110000000000
   6254                                                      10987654321098765432109876543210
   6255                                                      100001x01x1xxxxx001xxxxxxxxxxxxx
   6256                                                      ldff1sh.  */
   6257                                                   return 1674;
   6258                                                 }
   6259                                             }
   6260                                         }
   6261                                       else
   6262                                         {
   6263                                           if (((word >> 23) & 0x1) == 0)
   6264                                             {
   6265                                               /* 33222222222211111111110000000000
   6266                                                  10987654321098765432109876543210
   6267                                                  x10001x00x1xxxxx001xxxxxxxxxxxxx
   6268                                                  prfh.  */
   6269                                               return 1783;
   6270                                             }
   6271                                           else
   6272                                             {
   6273                                               if (((word >> 31) & 0x1) == 0)
   6274                                                 {
   6275                                                   if (((word >> 10) & 0x1) == 0)
   6276                                                     {
   6277                                                       if (((word >> 12) & 0x1) == 0)
   6278                                                         {
   6279                                                           if (((word >> 22) & 0x1) == 0)
   6280                                                             {
   6281                                                               /* 33222222222211111111110000000000
   6282                                                                  10987654321098765432109876543210
   6283                                                                  010001x0101xxxxx0010x0xxxxxxxxxx
   6284                                                                  sqdmlalb.  */
   6285                                                               return 2168;
   6286                                                             }
   6287                                                           else
   6288                                                             {
   6289                                                               /* 33222222222211111111110000000000
   6290                                                                  10987654321098765432109876543210
   6291                                                                  010001x0111xxxxx0010x0xxxxxxxxxx
   6292                                                                  sqdmlalb.  */
   6293                                                               return 2169;
   6294                                                             }
   6295                                                         }
   6296                                                       else
   6297                                                         {
   6298                                                           if (((word >> 22) & 0x1) == 0)
   6299                                                             {
   6300                                                               /* 33222222222211111111110000000000
   6301                                                                  10987654321098765432109876543210
   6302                                                                  010001x0101xxxxx0011x0xxxxxxxxxx
   6303                                                                  sqdmlslb.  */
   6304                                                               return 2175;
   6305                                                             }
   6306                                                           else
   6307                                                             {
   6308                                                               /* 33222222222211111111110000000000
   6309                                                                  10987654321098765432109876543210
   6310                                                                  010001x0111xxxxx0011x0xxxxxxxxxx
   6311                                                                  sqdmlslb.  */
   6312                                                               return 2176;
   6313                                                             }
   6314                                                         }
   6315                                                     }
   6316                                                   else
   6317                                                     {
   6318                                                       if (((word >> 12) & 0x1) == 0)
   6319                                                         {
   6320                                                           if (((word >> 22) & 0x1) == 0)
   6321                                                             {
   6322                                                               /* 33222222222211111111110000000000
   6323                                                                  10987654321098765432109876543210
   6324                                                                  010001x0101xxxxx0010x1xxxxxxxxxx
   6325                                                                  sqdmlalt.  */
   6326                                                               return 2172;
   6327                                                             }
   6328                                                           else
   6329                                                             {
   6330                                                               /* 33222222222211111111110000000000
   6331                                                                  10987654321098765432109876543210
   6332                                                                  010001x0111xxxxx0010x1xxxxxxxxxx
   6333                                                                  sqdmlalt.  */
   6334                                                               return 2173;
   6335                                                             }
   6336                                                         }
   6337                                                       else
   6338                                                         {
   6339                                                           if (((word >> 22) & 0x1) == 0)
   6340                                                             {
   6341                                                               /* 33222222222211111111110000000000
   6342                                                                  10987654321098765432109876543210
   6343                                                                  010001x0101xxxxx0011x1xxxxxxxxxx
   6344                                                                  sqdmlslt.  */
   6345                                                               return 2179;
   6346                                                             }
   6347                                                           else
   6348                                                             {
   6349                                                               /* 33222222222211111111110000000000
   6350                                                                  10987654321098765432109876543210
   6351                                                                  010001x0111xxxxx0011x1xxxxxxxxxx
   6352                                                                  sqdmlslt.  */
   6353                                                               return 2180;
   6354                                                             }
   6355                                                         }
   6356                                                     }
   6357                                                 }
   6358                                               else
   6359                                                 {
   6360                                                   /* 33222222222211111111110000000000
   6361                                                      10987654321098765432109876543210
   6362                                                      110001x01x1xxxxx001xxxxxxxxxxxxx
   6363                                                      ldff1sh.  */
   6364                                                   return 1680;
   6365                                                 }
   6366                                             }
   6367                                         }
   6368                                     }
   6369                                 }
   6370                               else
   6371                                 {
   6372                                   if (((word >> 30) & 0x1) == 0)
   6373                                     {
   6374                                       if (((word >> 31) & 0x1) == 0)
   6375                                         {
   6376                                           if (((word >> 21) & 0x1) == 0)
   6377                                             {
   6378                                               if (((word >> 16) & 0x1) == 0)
   6379                                                 {
   6380                                                   if (((word >> 17) & 0x1) == 0)
   6381                                                     {
   6382                                                       if (((word >> 18) & 0x1) == 0)
   6383                                                         {
   6384                                                           if (((word >> 19) & 0x1) == 0)
   6385                                                             {
   6386                                                               /* 33222222222211111111110000000000
   6387                                                                  10987654321098765432109876543210
   6388                                                                  000001x0xx0x0000101xxxxxxxxxxxxx
   6389                                                                  sxtb.  */
   6390                                                               return 1954;
   6391                                                             }
   6392                                                           else
   6393                                                             {
   6394                                                               /* 33222222222211111111110000000000
   6395                                                                  10987654321098765432109876543210
   6396                                                                  000001x0xx0x1000101xxxxxxxxxxxxx
   6397                                                                  cls.  */
   6398                                                               return 1319;
   6399                                                             }
   6400                                                         }
   6401                                                       else
   6402                                                         {
   6403                                                           if (((word >> 19) & 0x1) == 0)
   6404                                                             {
   6405                                                               /* 33222222222211111111110000000000
   6406                                                                  10987654321098765432109876543210
   6407                                                                  000001x0xx0x0100101xxxxxxxxxxxxx
   6408                                                                  sxtw.  */
   6409                                                               return 1956;
   6410                                                             }
   6411                                                           else
   6412                                                             {
   6413                                                               /* 33222222222211111111110000000000
   6414                                                                  10987654321098765432109876543210
   6415                                                                  000001x0xx0x1100101xxxxxxxxxxxxx
   6416                                                                  fabs.  */
   6417                                                               return 1381;
   6418                                                             }
   6419                                                         }
   6420                                                     }
   6421                                                   else
   6422                                                     {
   6423                                                       if (((word >> 18) & 0x1) == 0)
   6424                                                         {
   6425                                                           if (((word >> 19) & 0x1) == 0)
   6426                                                             {
   6427                                                               /* 33222222222211111111110000000000
   6428                                                                  10987654321098765432109876543210
   6429                                                                  000001x0xx0x0010101xxxxxxxxxxxxx
   6430                                                                  sxth.  */
   6431                                                               return 1955;
   6432                                                             }
   6433                                                           else
   6434                                                             {
   6435                                                               /* 33222222222211111111110000000000
   6436                                                                  10987654321098765432109876543210
   6437                                                                  000001x0xx0x1010101xxxxxxxxxxxxx
   6438                                                                  cnt.  */
   6439                                                               return 1348;
   6440                                                             }
   6441                                                         }
   6442                                                       else
   6443                                                         {
   6444                                                           if (((word >> 19) & 0x1) == 0)
   6445                                                             {
   6446                                                               /* 33222222222211111111110000000000
   6447                                                                  10987654321098765432109876543210
   6448                                                                  000001x0xx0x0110101xxxxxxxxxxxxx
   6449                                                                  abs.  */
   6450                                                               return 1277;
   6451                                                             }
   6452                                                           else
   6453                                                             {
   6454                                                               /* 33222222222211111111110000000000
   6455                                                                  10987654321098765432109876543210
   6456                                                                  000001x0xx0x1110101xxxxxxxxxxxxx
   6457                                                                  not.  */
   6458                                                               return 1755;
   6459                                                             }
   6460                                                         }
   6461                                                     }
   6462                                                 }
   6463                                               else
   6464                                                 {
   6465                                                   if (((word >> 17) & 0x1) == 0)
   6466                                                     {
   6467                                                       if (((word >> 18) & 0x1) == 0)
   6468                                                         {
   6469                                                           if (((word >> 19) & 0x1) == 0)
   6470                                                             {
   6471                                                               /* 33222222222211111111110000000000
   6472                                                                  10987654321098765432109876543210
   6473                                                                  000001x0xx0x0001101xxxxxxxxxxxxx
   6474                                                                  uxtb.  */
   6475                                                               return 2017;
   6476                                                             }
   6477                                                           else
   6478                                                             {
   6479                                                               /* 33222222222211111111110000000000
   6480                                                                  10987654321098765432109876543210
   6481                                                                  000001x0xx0x1001101xxxxxxxxxxxxx
   6482                                                                  clz.  */
   6483                                                               return 1320;
   6484                                                             }
   6485                                                         }
   6486                                                       else
   6487                                                         {
   6488                                                           if (((word >> 19) & 0x1) == 0)
   6489                                                             {
   6490                                                               /* 33222222222211111111110000000000
   6491                                                                  10987654321098765432109876543210
   6492                                                                  000001x0xx0x0101101xxxxxxxxxxxxx
   6493                                                                  uxtw.  */
   6494                                                               return 2019;
   6495                                                             }
   6496                                                           else
   6497                                                             {
   6498                                                               /* 33222222222211111111110000000000
   6499                                                                  10987654321098765432109876543210
   6500                                                                  000001x0xx0x1101101xxxxxxxxxxxxx
   6501                                                                  fneg.  */
   6502                                                               return 1458;
   6503                                                             }
   6504                                                         }
   6505                                                     }
   6506                                                   else
   6507                                                     {
   6508                                                       if (((word >> 18) & 0x1) == 0)
   6509                                                         {
   6510                                                           if (((word >> 19) & 0x1) == 0)
   6511                                                             {
   6512                                                               /* 33222222222211111111110000000000
   6513                                                                  10987654321098765432109876543210
   6514                                                                  000001x0xx0x0011101xxxxxxxxxxxxx
   6515                                                                  uxth.  */
   6516                                                               return 2018;
   6517                                                             }
   6518                                                           else
   6519                                                             {
   6520                                                               /* 33222222222211111111110000000000
   6521                                                                  10987654321098765432109876543210
   6522                                                                  000001x0xx0x1011101xxxxxxxxxxxxx
   6523                                                                  cnot.  */
   6524                                                               return 1347;
   6525                                                             }
   6526                                                         }
   6527                                                       else
   6528                                                         {
   6529                                                           /* 33222222222211111111110000000000
   6530                                                              10987654321098765432109876543210
   6531                                                              000001x0xx0xx111101xxxxxxxxxxxxx
   6532                                                              neg.  */
   6533                                                           return 1752;
   6534                                                         }
   6535                                                     }
   6536                                                 }
   6537                                             }
   6538                                           else
   6539                                             {
   6540                                               if (((word >> 12) & 0x1) == 0)
   6541                                                 {
   6542                                                   if (((word >> 23) & 0x1) == 0)
   6543                                                     {
   6544                                                       if (((word >> 22) & 0x1) == 0)
   6545                                                         {
   6546                                                           /* 33222222222211111111110000000000
   6547                                                              10987654321098765432109876543210
   6548                                                              000001x0001xxxxx1010xxxxxxxxxxxx
   6549                                                              adr.  */
   6550                                                           return 1283;
   6551                                                         }
   6552                                                       else
   6553                                                         {
   6554                                                           /* 33222222222211111111110000000000
   6555                                                              10987654321098765432109876543210
   6556                                                              000001x0011xxxxx1010xxxxxxxxxxxx
   6557                                                              adr.  */
   6558                                                           return 1284;
   6559                                                         }
   6560                                                     }
   6561                                                   else
   6562                                                     {
   6563                                                       /* 33222222222211111111110000000000
   6564                                                          10987654321098765432109876543210
   6565                                                          000001x01x1xxxxx1010xxxxxxxxxxxx
   6566                                                          adr.  */
   6567                                                       return 1285;
   6568                                                     }
   6569                                                 }
   6570                                               else
   6571                                                 {
   6572                                                   if (((word >> 10) & 0x1) == 0)
   6573                                                     {
   6574                                                       if (((word >> 11) & 0x1) == 0)
   6575                                                         {
   6576                                                           /* 33222222222211111111110000000000
   6577                                                              10987654321098765432109876543210
   6578                                                              000001x0xx1xxxxx101100xxxxxxxxxx
   6579                                                              ftssel.  */
   6580                                                           return 1484;
   6581                                                         }
   6582                                                       else
   6583                                                         {
   6584                                                           /* 33222222222211111111110000000000
   6585                                                              10987654321098765432109876543210
   6586                                                              000001x0xx1xxxxx101110xxxxxxxxxx
   6587                                                              fexpa.  */
   6588                                                           return 1428;
   6589                                                         }
   6590                                                     }
   6591                                                   else
   6592                                                     {
   6593                                                       /* 33222222222211111111110000000000
   6594                                                          10987654321098765432109876543210
   6595                                                          000001x0xx1xxxxx1011x1xxxxxxxxxx
   6596                                                          movprfx.  */
   6597                                                       return 1745;
   6598                                                     }
   6599                                                 }
   6600                                             }
   6601                                         }
   6602                                       else
   6603                                         {
   6604                                           if (((word >> 22) & 0x1) == 0)
   6605                                             {
   6606                                               if (((word >> 21) & 0x1) == 0)
   6607                                                 {
   6608                                                   if (((word >> 23) & 0x1) == 0)
   6609                                                     {
   6610                                                       /* 33222222222211111111110000000000
   6611                                                          10987654321098765432109876543210
   6612                                                          100001x0000xxxxx101xxxxxxxxxxxxx
   6613                                                          ldnt1b.  */
   6614                                                       return 2092;
   6615                                                     }
   6616                                                   else
   6617                                                     {
   6618                                                       /* 33222222222211111111110000000000
   6619                                                          10987654321098765432109876543210
   6620                                                          100001x0100xxxxx101xxxxxxxxxxxxx
   6621                                                          ldnt1h.  */
   6622                                                       return 2095;
   6623                                                     }
   6624                                                 }
   6625                                               else
   6626                                                 {
   6627                                                   if (((word >> 23) & 0x1) == 0)
   6628                                                     {
   6629                                                       /* 33222222222211111111110000000000
   6630                                                          10987654321098765432109876543210
   6631                                                          100001x0001xxxxx101xxxxxxxxxxxxx
   6632                                                          ldff1sb.  */
   6633                                                       return 1671;
   6634                                                     }
   6635                                                   else
   6636                                                     {
   6637                                                       /* 33222222222211111111110000000000
   6638                                                          10987654321098765432109876543210
   6639                                                          100001x0101xxxxx101xxxxxxxxxxxxx
   6640                                                          ldff1sh.  */
   6641                                                       return 1683;
   6642                                                     }
   6643                                                 }
   6644                                             }
   6645                                           else
   6646                                             {
   6647                                               if (((word >> 23) & 0x1) == 0)
   6648                                                 {
   6649                                                   /* 33222222222211111111110000000000
   6650                                                      10987654321098765432109876543210
   6651                                                      100001x001xxxxxx101xxxxxxxxxxxxx
   6652                                                      ld1rb.  */
   6653                                                   return 1539;
   6654                                                 }
   6655                                               else
   6656                                                 {
   6657                                                   /* 33222222222211111111110000000000
   6658                                                      10987654321098765432109876543210
   6659                                                      100001x011xxxxxx101xxxxxxxxxxxxx
   6660                                                      ld1rh.  */
   6661                                                   return 1543;
   6662                                                 }
   6663                                             }
   6664                                         }
   6665                                     }
   6666                                   else
   6667                                     {
   6668                                       if (((word >> 21) & 0x1) == 0)
   6669                                         {
   6670                                           if (((word >> 31) & 0x1) == 0)
   6671                                             {
   6672                                               if (((word >> 16) & 0x1) == 0)
   6673                                                 {
   6674                                                   if (((word >> 17) & 0x1) == 0)
   6675                                                     {
   6676                                                       if (((word >> 18) & 0x1) == 0)
   6677                                                         {
   6678                                                           if (((word >> 19) & 0x1) == 0)
   6679                                                             {
   6680                                                               /* 33222222222211111111110000000000
   6681                                                                  10987654321098765432109876543210
   6682                                                                  010001x0xx0x0000101xxxxxxxxxxxxx
   6683                                                                  urecpe.  */
   6684                                                               return 2303;
   6685                                                             }
   6686                                                           else
   6687                                                             {
   6688                                                               /* 33222222222211111111110000000000
   6689                                                                  10987654321098765432109876543210
   6690                                                                  010001x0xx0x1000101xxxxxxxxxxxxx
   6691                                                                  sqabs.  */
   6692                                                               return 2165;
   6693                                                             }
   6694                                                         }
   6695                                                       else
   6696                                                         {
   6697                                                           if (((word >> 20) & 0x1) == 0)
   6698                                                             {
   6699                                                               /* 33222222222211111111110000000000
   6700                                                                  10987654321098765432109876543210
   6701                                                                  010001x0xx00x100101xxxxxxxxxxxxx
   6702                                                                  sadalp.  */
   6703                                                               return 2129;
   6704                                                             }
   6705                                                           else
   6706                                                             {
   6707                                                               /* 33222222222211111111110000000000
   6708                                                                  10987654321098765432109876543210
   6709                                                                  010001x0xx01x100101xxxxxxxxxxxxx
   6710                                                                  smaxp.  */
   6711                                                               return 2143;
   6712                                                             }
   6713                                                         }
   6714                                                     }
   6715                                                   else
   6716                                                     {
   6717                                                       /* 33222222222211111111110000000000
   6718                                                          10987654321098765432109876543210
   6719                                                          010001x0xx0xxx10101xxxxxxxxxxxxx
   6720                                                          sminp.  */
   6721                                                       return 2144;
   6722                                                     }
   6723                                                 }
   6724                                               else
   6725                                                 {
   6726                                                   if (((word >> 17) & 0x1) == 0)
   6727                                                     {
   6728                                                       if (((word >> 18) & 0x1) == 0)
   6729                                                         {
   6730                                                           if (((word >> 19) & 0x1) == 0)
   6731                                                             {
   6732                                                               if (((word >> 20) & 0x1) == 0)
   6733                                                                 {
   6734                                                                   /* 33222222222211111111110000000000
   6735                                                                      10987654321098765432109876543210
   6736                                                                      010001x0xx000001101xxxxxxxxxxxxx
   6737                                                                      ursqrte.  */
   6738                                                                   return 2308;
   6739                                                                 }
   6740                                                               else
   6741                                                                 {
   6742                                                                   /* 33222222222211111111110000000000
   6743                                                                      10987654321098765432109876543210
   6744                                                                      010001x0xx010001101xxxxxxxxxxxxx
   6745                                                                      addp.  */
   6746                                                                   return 2054;
   6747                                                                 }
   6748                                                             }
   6749                                                           else
   6750                                                             {
   6751                                                               /* 33222222222211111111110000000000
   6752                                                                  10987654321098765432109876543210
   6753                                                                  010001x0xx0x1001101xxxxxxxxxxxxx
   6754                                                                  sqneg.  */
   6755                                                               return 2192;
   6756                                                             }
   6757                                                         }
   6758                                                       else
   6759                                                         {
   6760                                                           if (((word >> 20) & 0x1) == 0)
   6761                                                             {
   6762                                                               /* 33222222222211111111110000000000
   6763                                                                  10987654321098765432109876543210
   6764                                                                  010001x0xx00x101101xxxxxxxxxxxxx
   6765                                                                  uadalp.  */
   6766                                                               return 2260;
   6767                                                             }
   6768                                                           else
   6769                                                             {
   6770                                                               /* 33222222222211111111110000000000
   6771                                                                  10987654321098765432109876543210
   6772                                                                  010001x0xx01x101101xxxxxxxxxxxxx
   6773                                                                  umaxp.  */
   6774                                                               return 2268;
   6775                                                             }
   6776                                                         }
   6777                                                     }
   6778                                                   else
   6779                                                     {
   6780                                                       /* 33222222222211111111110000000000
   6781                                                          10987654321098765432109876543210
   6782                                                          010001x0xx0xxx11101xxxxxxxxxxxxx
   6783                                                          uminp.  */
   6784                                                       return 2269;
   6785                                                     }
   6786                                                 }
   6787                                             }
   6788                                           else
   6789                                             {
   6790                                               if (((word >> 23) & 0x1) == 0)
   6791                                                 {
   6792                                                   /* 33222222222211111111110000000000
   6793                                                      10987654321098765432109876543210
   6794                                                      110001x00x0xxxxx101xxxxxxxxxxxxx
   6795                                                      ldff1sb.  */
   6796                                                   return 1670;
   6797                                                 }
   6798                                               else
   6799                                                 {
   6800                                                   /* 33222222222211111111110000000000
   6801                                                      10987654321098765432109876543210
   6802                                                      110001x01x0xxxxx101xxxxxxxxxxxxx
   6803                                                      ldff1sh.  */
   6804                                                   return 1681;
   6805                                                 }
   6806                                             }
   6807                                         }
   6808                                       else
   6809                                         {
   6810                                           if (((word >> 22) & 0x1) == 0)
   6811                                             {
   6812                                               if (((word >> 23) & 0x1) == 0)
   6813                                                 {
   6814                                                   /* 33222222222211111111110000000000
   6815                                                      10987654321098765432109876543210
   6816                                                      x10001x0001xxxxx101xxxxxxxxxxxxx
   6817                                                      ldff1sb.  */
   6818                                                   return 1672;
   6819                                                 }
   6820                                               else
   6821                                                 {
   6822                                                   if (((word >> 31) & 0x1) == 0)
   6823                                                     {
   6824                                                       if (((word >> 10) & 0x1) == 0)
   6825                                                         {
   6826                                                           if (((word >> 12) & 0x1) == 0)
   6827                                                             {
   6828                                                               /* 33222222222211111111110000000000
   6829                                                                  10987654321098765432109876543210
   6830                                                                  010001x0101xxxxx1010x0xxxxxxxxxx
   6831                                                                  smlslb.  */
   6832                                                               return 2151;
   6833                                                             }
   6834                                                           else
   6835                                                             {
   6836                                                               /* 33222222222211111111110000000000
   6837                                                                  10987654321098765432109876543210
   6838                                                                  010001x0101xxxxx1011x0xxxxxxxxxx
   6839                                                                  umlslb.  */
   6840                                                               return 2276;
   6841                                                             }
   6842                                                         }
   6843                                                       else
   6844                                                         {
   6845                                                           if (((word >> 12) & 0x1) == 0)
   6846                                                             {
   6847                                                               /* 33222222222211111111110000000000
   6848                                                                  10987654321098765432109876543210
   6849                                                                  010001x0101xxxxx1010x1xxxxxxxxxx
   6850                                                                  smlslt.  */
   6851                                                               return 2154;
   6852                                                             }
   6853                                                           else
   6854                                                             {
   6855                                                               /* 33222222222211111111110000000000
   6856                                                                  10987654321098765432109876543210
   6857                                                                  010001x0101xxxxx1011x1xxxxxxxxxx
   6858                                                                  umlslt.  */
   6859                                                               return 2279;
   6860                                                             }
   6861                                                         }
   6862                                                     }
   6863                                                   else
   6864                                                     {
   6865                                                       /* 33222222222211111111110000000000
   6866                                                          10987654321098765432109876543210
   6867                                                          110001x0101xxxxx101xxxxxxxxxxxxx
   6868                                                          ldff1sh.  */
   6869                                                       return 1684;
   6870                                                     }
   6871                                                 }
   6872                                             }
   6873                                           else
   6874                                             {
   6875                                               if (((word >> 23) & 0x1) == 0)
   6876                                                 {
   6877                                                   /* 33222222222211111111110000000000
   6878                                                      10987654321098765432109876543210
   6879                                                      x10001x0011xxxxx101xxxxxxxxxxxxx
   6880                                                      prfh.  */
   6881                                                   return 1784;
   6882                                                 }
   6883                                               else
   6884                                                 {
   6885                                                   if (((word >> 31) & 0x1) == 0)
   6886                                                     {
   6887                                                       if (((word >> 10) & 0x1) == 0)
   6888                                                         {
   6889                                                           if (((word >> 12) & 0x1) == 0)
   6890                                                             {
   6891                                                               /* 33222222222211111111110000000000
   6892                                                                  10987654321098765432109876543210
   6893                                                                  010001x0111xxxxx1010x0xxxxxxxxxx
   6894                                                                  smlslb.  */
   6895                                                               return 2152;
   6896                                                             }
   6897                                                           else
   6898                                                             {
   6899                                                               /* 33222222222211111111110000000000
   6900                                                                  10987654321098765432109876543210
   6901                                                                  010001x0111xxxxx1011x0xxxxxxxxxx
   6902                                                                  umlslb.  */
   6903                                                               return 2277;
   6904                                                             }
   6905                                                         }
   6906                                                       else
   6907                                                         {
   6908                                                           if (((word >> 12) & 0x1) == 0)
   6909                                                             {
   6910                                                               /* 33222222222211111111110000000000
   6911                                                                  10987654321098765432109876543210
   6912                                                                  010001x0111xxxxx1010x1xxxxxxxxxx
   6913                                                                  smlslt.  */
   6914                                                               return 2155;
   6915                                                             }
   6916                                                           else
   6917                                                             {
   6918                                                               /* 33222222222211111111110000000000
   6919                                                                  10987654321098765432109876543210
   6920                                                                  010001x0111xxxxx1011x1xxxxxxxxxx
   6921                                                                  umlslt.  */
   6922                                                               return 2280;
   6923                                                             }
   6924                                                         }
   6925                                                     }
   6926                                                   else
   6927                                                     {
   6928                                                       /* 33222222222211111111110000000000
   6929                                                          10987654321098765432109876543210
   6930                                                          110001x0111xxxxx101xxxxxxxxxxxxx
   6931                                                          ldff1sh.  */
   6932                                                       return 1682;
   6933                                                     }
   6934                                                 }
   6935                                             }
   6936                                         }
   6937                                     }
   6938                                 }
   6939                             }
   6940                           else
   6941                             {
   6942                               if (((word >> 15) & 0x1) == 0)
   6943                                 {
   6944                                   if (((word >> 21) & 0x1) == 0)
   6945                                     {
   6946                                       if (((word >> 30) & 0x1) == 0)
   6947                                         {
   6948                                           if (((word >> 31) & 0x1) == 0)
   6949                                             {
   6950                                               /* 33222222222211111111110000000000
   6951                                                  10987654321098765432109876543210
   6952                                                  000001x0xx0xxxxx011xxxxxxxxxxxxx
   6953                                                  mls.  */
   6954                                               return 1744;
   6955                                             }
   6956                                           else
   6957                                             {
   6958                                               if (((word >> 23) & 0x1) == 0)
   6959                                                 {
   6960                                                   /* 33222222222211111111110000000000
   6961                                                      10987654321098765432109876543210
   6962                                                      100001x00x0xxxxx011xxxxxxxxxxxxx
   6963                                                      ldff1b.  */
   6964                                                   return 1628;
   6965                                                 }
   6966                                               else
   6967                                                 {
   6968                                                   /* 33222222222211111111110000000000
   6969                                                      10987654321098765432109876543210
   6970                                                      100001x01x0xxxxx011xxxxxxxxxxxxx
   6971                                                      ldff1h.  */
   6972                                                   return 1648;
   6973                                                 }
   6974                                             }
   6975                                         }
   6976                                       else
   6977                                         {
   6978                                           if (((word >> 31) & 0x1) == 0)
   6979                                             {
   6980                                               if (((word >> 10) & 0x1) == 0)
   6981                                                 {
   6982                                                   if (((word >> 11) & 0x1) == 0)
   6983                                                     {
   6984                                                       if (((word >> 12) & 0x1) == 0)
   6985                                                         {
   6986                                                           /* 33222222222211111111110000000000
   6987                                                              10987654321098765432109876543210
   6988                                                              010001x0xx0xxxxx011000xxxxxxxxxx
   6989                                                              sqdmlalb.  */
   6990                                                           return 2170;
   6991                                                         }
   6992                                                       else
   6993                                                         {
   6994                                                           /* 33222222222211111111110000000000
   6995                                                              10987654321098765432109876543210
   6996                                                              010001x0xx0xxxxx011100xxxxxxxxxx
   6997                                                              sqrdmlah.  */
   6998                                                           return 2199;
   6999                                                         }
   7000                                                     }
   7001                                                   else
   7002                                                     {
   7003                                                       if (((word >> 12) & 0x1) == 0)
   7004                                                         {
   7005                                                           /* 33222222222211111111110000000000
   7006                                                              10987654321098765432109876543210
   7007                                                              010001x0xx0xxxxx011010xxxxxxxxxx
   7008                                                              sqdmlslb.  */
   7009                                                           return 2177;
   7010                                                         }
   7011                                                       else
   7012                                                         {
   7013                                                           /* 33222222222211111111110000000000
   7014                                                              10987654321098765432109876543210
   7015                                                              010001x0xx0xxxxx011110xxxxxxxxxx
   7016                                                              usdot.  */
   7017                                                           return 2397;
   7018                                                         }
   7019                                                     }
   7020                                                 }
   7021                                               else
   7022                                                 {
   7023                                                   if (((word >> 11) & 0x1) == 0)
   7024                                                     {
   7025                                                       if (((word >> 12) & 0x1) == 0)
   7026                                                         {
   7027                                                           /* 33222222222211111111110000000000
   7028                                                              10987654321098765432109876543210
   7029                                                              010001x0xx0xxxxx011001xxxxxxxxxx
   7030                                                              sqdmlalt.  */
   7031                                                           return 2174;
   7032                                                         }
   7033                                                       else
   7034                                                         {
   7035                                                           /* 33222222222211111111110000000000
   7036                                                              10987654321098765432109876543210
   7037                                                              010001x0xx0xxxxx011101xxxxxxxxxx
   7038                                                              sqrdmlsh.  */
   7039                                                           return 2203;
   7040                                                         }
   7041                                                     }
   7042                                                   else
   7043                                                     {
   7044                                                       /* 33222222222211111111110000000000
   7045                                                          10987654321098765432109876543210
   7046                                                          010001x0xx0xxxxx011x11xxxxxxxxxx
   7047                                                          sqdmlslt.  */
   7048                                                       return 2181;
   7049                                                     }
   7050                                                 }
   7051                                             }
   7052                                           else
   7053                                             {
   7054                                               if (((word >> 23) & 0x1) == 0)
   7055                                                 {
   7056                                                   /* 33222222222211111111110000000000
   7057                                                      10987654321098765432109876543210
   7058                                                      110001x00x0xxxxx011xxxxxxxxxxxxx
   7059                                                      ldff1b.  */
   7060                                                   return 1637;
   7061                                                 }
   7062                                               else
   7063                                                 {
   7064                                                   /* 33222222222211111111110000000000
   7065                                                      10987654321098765432109876543210
   7066                                                      110001x01x0xxxxx011xxxxxxxxxxxxx
   7067                                                      ldff1h.  */
   7068                                                   return 1656;
   7069                                                 }
   7070                                             }
   7071                                         }
   7072                                     }
   7073                                   else
   7074                                     {
   7075                                       if (((word >> 30) & 0x1) == 0)
   7076                                         {
   7077                                           if (((word >> 31) & 0x1) == 0)
   7078                                             {
   7079                                               if (((word >> 10) & 0x1) == 0)
   7080                                                 {
   7081                                                   if (((word >> 11) & 0x1) == 0)
   7082                                                     {
   7083                                                       if (((word >> 12) & 0x1) == 0)
   7084                                                         {
   7085                                                           /* 33222222222211111111110000000000
   7086                                                              10987654321098765432109876543210
   7087                                                              000001x0xx1xxxxx011000xxxxxxxxxx
   7088                                                              mul.  */
   7089                                                           return 2112;
   7090                                                         }
   7091                                                       else
   7092                                                         {
   7093                                                           /* 33222222222211111111110000000000
   7094                                                              10987654321098765432109876543210
   7095                                                              000001x0xx1xxxxx011100xxxxxxxxxx
   7096                                                              sqdmulh.  */
   7097                                                           return 2185;
   7098                                                         }
   7099                                                     }
   7100                                                   else
   7101                                                     {
   7102                                                       /* 33222222222211111111110000000000
   7103                                                          10987654321098765432109876543210
   7104                                                          000001x0xx1xxxxx011x10xxxxxxxxxx
   7105                                                          smulh.  */
   7106                                                       return 2157;
   7107                                                     }
   7108                                                 }
   7109                                               else
   7110                                                 {
   7111                                                   if (((word >> 11) & 0x1) == 0)
   7112                                                     {
   7113                                                       if (((word >> 12) & 0x1) == 0)
   7114                                                         {
   7115                                                           /* 33222222222211111111110000000000
   7116                                                              10987654321098765432109876543210
   7117                                                              000001x0xx1xxxxx011001xxxxxxxxxx
   7118                                                              pmul.  */
   7119                                                           return 2115;
   7120                                                         }
   7121                                                       else
   7122                                                         {
   7123                                                           /* 33222222222211111111110000000000
   7124                                                              10987654321098765432109876543210
   7125                                                              000001x0xx1xxxxx011101xxxxxxxxxx
   7126                                                              sqrdmulh.  */
   7127                                                           return 2207;
   7128                                                         }
   7129                                                     }
   7130                                                   else
   7131                                                     {
   7132                                                       /* 33222222222211111111110000000000
   7133                                                          10987654321098765432109876543210
   7134                                                          000001x0xx1xxxxx011x11xxxxxxxxxx
   7135                                                          umulh.  */
   7136                                                       return 2282;
   7137                                                     }
   7138                                                 }
   7139                                             }
   7140                                           else
   7141                                             {
   7142                                               if (((word >> 23) & 0x1) == 0)
   7143                                                 {
   7144                                                   /* 33222222222211111111110000000000
   7145                                                      10987654321098765432109876543210
   7146                                                      100001x00x1xxxxx011xxxxxxxxxxxxx
   7147                                                      prfd.  */
   7148                                                   return 1774;
   7149                                                 }
   7150                                               else
   7151                                                 {
   7152                                                   /* 33222222222211111111110000000000
   7153                                                      10987654321098765432109876543210
   7154                                                      100001x01x1xxxxx011xxxxxxxxxxxxx
   7155                                                      ldff1h.  */
   7156                                                   return 1649;
   7157                                                 }
   7158                                             }
   7159                                         }
   7160                                       else
   7161                                         {
   7162                                           if (((word >> 23) & 0x1) == 0)
   7163                                             {
   7164                                               /* 33222222222211111111110000000000
   7165                                                  10987654321098765432109876543210
   7166                                                  x10001x00x1xxxxx011xxxxxxxxxxxxx
   7167                                                  prfd.  */
   7168                                               return 1776;
   7169                                             }
   7170                                           else
   7171                                             {
   7172                                               if (((word >> 31) & 0x1) == 0)
   7173                                                 {
   7174                                                   if (((word >> 12) & 0x1) == 0)
   7175                                                     {
   7176                                                       if (((word >> 22) & 0x1) == 0)
   7177                                                         {
   7178                                                           /* 33222222222211111111110000000000
   7179                                                              10987654321098765432109876543210
   7180                                                              010001x0101xxxxx0110xxxxxxxxxxxx
   7181                                                              cmla.  */
   7182                                                           return 2064;
   7183                                                         }
   7184                                                       else
   7185                                                         {
   7186                                                           /* 33222222222211111111110000000000
   7187                                                              10987654321098765432109876543210
   7188                                                              010001x0111xxxxx0110xxxxxxxxxxxx
   7189                                                              cmla.  */
   7190                                                           return 2065;
   7191                                                         }
   7192                                                     }
   7193                                                   else
   7194                                                     {
   7195                                                       if (((word >> 22) & 0x1) == 0)
   7196                                                         {
   7197                                                           /* 33222222222211111111110000000000
   7198                                                              10987654321098765432109876543210
   7199                                                              010001x0101xxxxx0111xxxxxxxxxxxx
   7200                                                              sqrdcmlah.  */
   7201                                                           return 2193;
   7202                                                         }
   7203                                                       else
   7204                                                         {
   7205                                                           /* 33222222222211111111110000000000
   7206                                                              10987654321098765432109876543210
   7207                                                              010001x0111xxxxx0111xxxxxxxxxxxx
   7208                                                              sqrdcmlah.  */
   7209                                                           return 2194;
   7210                                                         }
   7211                                                     }
   7212                                                 }
   7213                                               else
   7214                                                 {
   7215                                                   /* 33222222222211111111110000000000
   7216                                                      10987654321098765432109876543210
   7217                                                      110001x01x1xxxxx011xxxxxxxxxxxxx
   7218                                                      ldff1h.  */
   7219                                                   return 1657;
   7220                                                 }
   7221                                             }
   7222                                         }
   7223                                     }
   7224                                 }
   7225                               else
   7226                                 {
   7227                                   if (((word >> 30) & 0x1) == 0)
   7228                                     {
   7229                                       if (((word >> 31) & 0x1) == 0)
   7230                                         {
   7231                                           if (((word >> 21) & 0x1) == 0)
   7232                                             {
   7233                                               /* 33222222222211111111110000000000
   7234                                                  10987654321098765432109876543210
   7235                                                  000001x0xx0xxxxx111xxxxxxxxxxxxx
   7236                                                  msb.  */
   7237                                               return 1747;
   7238                                             }
   7239                                           else
   7240                                             {
   7241                                               if (((word >> 10) & 0x1) == 0)
   7242                                                 {
   7243                                                   if (((word >> 11) & 0x1) == 0)
   7244                                                     {
   7245                                                       if (((word >> 12) & 0x1) == 0)
   7246                                                         {
   7247                                                           if (((word >> 20) & 0x1) == 0)
   7248                                                             {
   7249                                                               if (((word >> 22) & 0x1) == 0)
   7250                                                                 {
   7251                                                                   if (((word >> 23) & 0x1) == 0)
   7252                                                                     {
   7253                                                                       /* 33222222222211111111110000000000
   7254                                                                          10987654321098765432109876543210
   7255                                                                          000001x00010xxxx111000xxxxxxxxxx
   7256                                                                          cntb.  */
   7257                                                                       return 1349;
   7258                                                                     }
   7259                                                                   else
   7260                                                                     {
   7261                                                                       /* 33222222222211111111110000000000
   7262                                                                          10987654321098765432109876543210
   7263                                                                          000001x01010xxxx111000xxxxxxxxxx
   7264                                                                          cntw.  */
   7265                                                                       return 1353;
   7266                                                                     }
   7267                                                                 }
   7268                                                               else
   7269                                                                 {
   7270                                                                   if (((word >> 23) & 0x1) == 0)
   7271                                                                     {
   7272                                                                       /* 33222222222211111111110000000000
   7273                                                                          10987654321098765432109876543210
   7274                                                                          000001x00110xxxx111000xxxxxxxxxx
   7275                                                                          cnth.  */
   7276                                                                       return 1351;
   7277                                                                     }
   7278                                                                   else
   7279                                                                     {
   7280                                                                       /* 33222222222211111111110000000000
   7281                                                                          10987654321098765432109876543210
   7282                                                                          000001x01110xxxx111000xxxxxxxxxx
   7283                                                                          cntd.  */
   7284                                                                       return 1350;
   7285                                                                     }
   7286                                                                 }
   7287                                                             }
   7288                                                           else
   7289                                                             {
   7290                                                               if (((word >> 22) & 0x1) == 0)
   7291                                                                 {
   7292                                                                   if (((word >> 23) & 0x1) == 0)
   7293                                                                     {
   7294                                                                       /* 33222222222211111111110000000000
   7295                                                                          10987654321098765432109876543210
   7296                                                                          000001x00011xxxx111000xxxxxxxxxx
   7297                                                                          incb.  */
   7298                                                                       return 1485;
   7299                                                                     }
   7300                                                                   else
   7301                                                                     {
   7302                                                                       /* 33222222222211111111110000000000
   7303                                                                          10987654321098765432109876543210
   7304                                                                          000001x01011xxxx111000xxxxxxxxxx
   7305                                                                          incw.  */
   7306                                                                       return 1493;
   7307                                                                     }
   7308                                                                 }
   7309                                                               else
   7310                                                                 {
   7311                                                                   if (((word >> 23) & 0x1) == 0)
   7312                                                                     {
   7313                                                                       /* 33222222222211111111110000000000
   7314                                                                          10987654321098765432109876543210
   7315                                                                          000001x00111xxxx111000xxxxxxxxxx
   7316                                                                          inch.  */
   7317                                                                       return 1489;
   7318                                                                     }
   7319                                                                   else
   7320                                                                     {
   7321                                                                       /* 33222222222211111111110000000000
   7322                                                                          10987654321098765432109876543210
   7323                                                                          000001x01111xxxx111000xxxxxxxxxx
   7324                                                                          incd.  */
   7325                                                                       return 1487;
   7326                                                                     }
   7327                                                                 }
   7328                                                             }
   7329                                                         }
   7330                                                       else
   7331                                                         {
   7332                                                           if (((word >> 20) & 0x1) == 0)
   7333                                                             {
   7334                                                               if (((word >> 22) & 0x1) == 0)
   7335                                                                 {
   7336                                                                   if (((word >> 23) & 0x1) == 0)
   7337                                                                     {
   7338                                                                       /* 33222222222211111111110000000000
   7339                                                                          10987654321098765432109876543210
   7340                                                                          000001x00010xxxx111100xxxxxxxxxx
   7341                                                                          sqincb.  */
   7342                                                                       return 1852;
   7343                                                                     }
   7344                                                                   else
   7345                                                                     {
   7346                                                                       /* 33222222222211111111110000000000
   7347                                                                          10987654321098765432109876543210
   7348                                                                          000001x01010xxxx111100xxxxxxxxxx
   7349                                                                          sqincw.  */
   7350                                                                       return 1864;
   7351                                                                     }
   7352                                                                 }
   7353                                                               else
   7354                                                                 {
   7355                                                                   if (((word >> 23) & 0x1) == 0)
   7356                                                                     {
   7357                                                                       /* 33222222222211111111110000000000
   7358                                                                          10987654321098765432109876543210
   7359                                                                          000001x00110xxxx111100xxxxxxxxxx
   7360                                                                          sqinch.  */
   7361                                                                       return 1858;
   7362                                                                     }
   7363                                                                   else
   7364                                                                     {
   7365                                                                       /* 33222222222211111111110000000000
   7366                                                                          10987654321098765432109876543210
   7367                                                                          000001x01110xxxx111100xxxxxxxxxx
   7368                                                                          sqincd.  */
   7369                                                                       return 1855;
   7370                                                                     }
   7371                                                                 }
   7372                                                             }
   7373                                                           else
   7374                                                             {
   7375                                                               if (((word >> 22) & 0x1) == 0)
   7376                                                                 {
   7377                                                                   if (((word >> 23) & 0x1) == 0)
   7378                                                                     {
   7379                                                                       /* 33222222222211111111110000000000
   7380                                                                          10987654321098765432109876543210
   7381                                                                          000001x00011xxxx111100xxxxxxxxxx
   7382                                                                          sqincb.  */
   7383                                                                       return 1851;
   7384                                                                     }
   7385                                                                   else
   7386                                                                     {
   7387                                                                       /* 33222222222211111111110000000000
   7388                                                                          10987654321098765432109876543210
   7389                                                                          000001x01011xxxx111100xxxxxxxxxx
   7390                                                                          sqincw.  */
   7391                                                                       return 1863;
   7392                                                                     }
   7393                                                                 }
   7394                                                               else
   7395                                                                 {
   7396                                                                   if (((word >> 23) & 0x1) == 0)
   7397                                                                     {
   7398                                                                       /* 33222222222211111111110000000000
   7399                                                                          10987654321098765432109876543210
   7400                                                                          000001x00111xxxx111100xxxxxxxxxx
   7401                                                                          sqinch.  */
   7402                                                                       return 1857;
   7403                                                                     }
   7404                                                                   else
   7405                                                                     {
   7406                                                                       /* 33222222222211111111110000000000
   7407                                                                          10987654321098765432109876543210
   7408                                                                          000001x01111xxxx111100xxxxxxxxxx
   7409                                                                          sqincd.  */
   7410                                                                       return 1854;
   7411                                                                     }
   7412                                                                 }
   7413                                                             }
   7414                                                         }
   7415                                                     }
   7416                                                   else
   7417                                                     {
   7418                                                       if (((word >> 20) & 0x1) == 0)
   7419                                                         {
   7420                                                           if (((word >> 22) & 0x1) == 0)
   7421                                                             {
   7422                                                               if (((word >> 23) & 0x1) == 0)
   7423                                                                 {
   7424                                                                   /* 33222222222211111111110000000000
   7425                                                                      10987654321098765432109876543210
   7426                                                                      000001x00010xxxx111x10xxxxxxxxxx
   7427                                                                      sqdecb.  */
   7428                                                                   return 1838;
   7429                                                                 }
   7430                                                               else
   7431                                                                 {
   7432                                                                   /* 33222222222211111111110000000000
   7433                                                                      10987654321098765432109876543210
   7434                                                                      000001x01010xxxx111x10xxxxxxxxxx
   7435                                                                      sqdecw.  */
   7436                                                                   return 1850;
   7437                                                                 }
   7438                                                             }
   7439                                                           else
   7440                                                             {
   7441                                                               if (((word >> 23) & 0x1) == 0)
   7442                                                                 {
   7443                                                                   /* 33222222222211111111110000000000
   7444                                                                      10987654321098765432109876543210
   7445                                                                      000001x00110xxxx111x10xxxxxxxxxx
   7446                                                                      sqdech.  */
   7447                                                                   return 1844;
   7448                                                                 }
   7449                                                               else
   7450                                                                 {
   7451                                                                   /* 33222222222211111111110000000000
   7452                                                                      10987654321098765432109876543210
   7453                                                                      000001x01110xxxx111x10xxxxxxxxxx
   7454                                                                      sqdecd.  */
   7455                                                                   return 1841;
   7456                                                                 }
   7457                                                             }
   7458                                                         }
   7459                                                       else
   7460                                                         {
   7461                                                           if (((word >> 22) & 0x1) == 0)
   7462                                                             {
   7463                                                               if (((word >> 23) & 0x1) == 0)
   7464                                                                 {
   7465                                                                   /* 33222222222211111111110000000000
   7466                                                                      10987654321098765432109876543210
   7467                                                                      000001x00011xxxx111x10xxxxxxxxxx
   7468                                                                      sqdecb.  */
   7469                                                                   return 1837;
   7470                                                                 }
   7471                                                               else
   7472                                                                 {
   7473                                                                   /* 33222222222211111111110000000000
   7474                                                                      10987654321098765432109876543210
   7475                                                                      000001x01011xxxx111x10xxxxxxxxxx
   7476                                                                      sqdecw.  */
   7477                                                                   return 1849;
   7478                                                                 }
   7479                                                             }
   7480                                                           else
   7481                                                             {
   7482                                                               if (((word >> 23) & 0x1) == 0)
   7483                                                                 {
   7484                                                                   /* 33222222222211111111110000000000
   7485                                                                      10987654321098765432109876543210
   7486                                                                      000001x00111xxxx111x10xxxxxxxxxx
   7487                                                                      sqdech.  */
   7488                                                                   return 1843;
   7489                                                                 }
   7490                                                               else
   7491                                                                 {
   7492                                                                   /* 33222222222211111111110000000000
   7493                                                                      10987654321098765432109876543210
   7494                                                                      000001x01111xxxx111x10xxxxxxxxxx
   7495                                                                      sqdecd.  */
   7496                                                                   return 1840;
   7497                                                                 }
   7498                                                             }
   7499                                                         }
   7500                                                     }
   7501                                                 }
   7502                                               else
   7503                                                 {
   7504                                                   if (((word >> 11) & 0x1) == 0)
   7505                                                     {
   7506                                                       if (((word >> 12) & 0x1) == 0)
   7507                                                         {
   7508                                                           if (((word >> 22) & 0x1) == 0)
   7509                                                             {
   7510                                                               if (((word >> 23) & 0x1) == 0)
   7511                                                                 {
   7512                                                                   /* 33222222222211111111110000000000
   7513                                                                      10987654321098765432109876543210
   7514                                                                      000001x0001xxxxx111001xxxxxxxxxx
   7515                                                                      decb.  */
   7516                                                                   return 1360;
   7517                                                                 }
   7518                                                               else
   7519                                                                 {
   7520                                                                   /* 33222222222211111111110000000000
   7521                                                                      10987654321098765432109876543210
   7522                                                                      000001x0101xxxxx111001xxxxxxxxxx
   7523                                                                      decw.  */
   7524                                                                   return 1368;
   7525                                                                 }
   7526                                                             }
   7527                                                           else
   7528                                                             {
   7529                                                               if (((word >> 23) & 0x1) == 0)
   7530                                                                 {
   7531                                                                   /* 33222222222211111111110000000000
   7532                                                                      10987654321098765432109876543210
   7533                                                                      000001x0011xxxxx111001xxxxxxxxxx
   7534                                                                      dech.  */
   7535                                                                   return 1364;
   7536                                                                 }
   7537                                                               else
   7538                                                                 {
   7539                                                                   /* 33222222222211111111110000000000
   7540                                                                      10987654321098765432109876543210
   7541                                                                      000001x0111xxxxx111001xxxxxxxxxx
   7542                                                                      decd.  */
   7543                                                                   return 1362;
   7544                                                                 }
   7545                                                             }
   7546                                                         }
   7547                                                       else
   7548                                                         {
   7549                                                           if (((word >> 20) & 0x1) == 0)
   7550                                                             {
   7551                                                               if (((word >> 22) & 0x1) == 0)
   7552                                                                 {
   7553                                                                   if (((word >> 23) & 0x1) == 0)
   7554                                                                     {
   7555                                                                       /* 33222222222211111111110000000000
   7556                                                                          10987654321098765432109876543210
   7557                                                                          000001x00010xxxx111101xxxxxxxxxx
   7558                                                                          uqincb.  */
   7559                                                                       return 1999;
   7560                                                                     }
   7561                                                                   else
   7562                                                                     {
   7563                                                                       /* 33222222222211111111110000000000
   7564                                                                          10987654321098765432109876543210
   7565                                                                          000001x01010xxxx111101xxxxxxxxxx
   7566                                                                          uqincw.  */
   7567                                                                       return 2011;
   7568                                                                     }
   7569                                                                 }
   7570                                                               else
   7571                                                                 {
   7572                                                                   if (((word >> 23) & 0x1) == 0)
   7573                                                                     {
   7574                                                                       /* 33222222222211111111110000000000
   7575                                                                          10987654321098765432109876543210
   7576                                                                          000001x00110xxxx111101xxxxxxxxxx
   7577                                                                          uqinch.  */
   7578                                                                       return 2005;
   7579                                                                     }
   7580                                                                   else
   7581                                                                     {
   7582                                                                       /* 33222222222211111111110000000000
   7583                                                                          10987654321098765432109876543210
   7584                                                                          000001x01110xxxx111101xxxxxxxxxx
   7585                                                                          uqincd.  */
   7586                                                                       return 2002;
   7587                                                                     }
   7588                                                                 }
   7589                                                             }
   7590                                                           else
   7591                                                             {
   7592                                                               if (((word >> 22) & 0x1) == 0)
   7593                                                                 {
   7594                                                                   if (((word >> 23) & 0x1) == 0)
   7595                                                                     {
   7596                                                                       /* 33222222222211111111110000000000
   7597                                                                          10987654321098765432109876543210
   7598                                                                          000001x00011xxxx111101xxxxxxxxxx
   7599                                                                          uqincb.  */
   7600                                                                       return 2000;
   7601                                                                     }
   7602                                                                   else
   7603                                                                     {
   7604                                                                       /* 33222222222211111111110000000000
   7605                                                                          10987654321098765432109876543210
   7606                                                                          000001x01011xxxx111101xxxxxxxxxx
   7607                                                                          uqincw.  */
   7608                                                                       return 2012;
   7609                                                                     }
   7610                                                                 }
   7611                                                               else
   7612                                                                 {
   7613                                                                   if (((word >> 23) & 0x1) == 0)
   7614                                                                     {
   7615                                                                       /* 33222222222211111111110000000000
   7616                                                                          10987654321098765432109876543210
   7617                                                                          000001x00111xxxx111101xxxxxxxxxx
   7618                                                                          uqinch.  */
   7619                                                                       return 2006;
   7620                                                                     }
   7621                                                                   else
   7622                                                                     {
   7623                                                                       /* 33222222222211111111110000000000
   7624                                                                          10987654321098765432109876543210
   7625                                                                          000001x01111xxxx111101xxxxxxxxxx
   7626                                                                          uqincd.  */
   7627                                                                       return 2003;
   7628                                                                     }
   7629                                                                 }
   7630                                                             }
   7631                                                         }
   7632                                                     }
   7633                                                   else
   7634                                                     {
   7635                                                       if (((word >> 20) & 0x1) == 0)
   7636                                                         {
   7637                                                           if (((word >> 22) & 0x1) == 0)
   7638                                                             {
   7639                                                               if (((word >> 23) & 0x1) == 0)
   7640                                                                 {
   7641                                                                   /* 33222222222211111111110000000000
   7642                                                                      10987654321098765432109876543210
   7643                                                                      000001x00010xxxx111x11xxxxxxxxxx
   7644                                                                      uqdecb.  */
   7645                                                                   return 1985;
   7646                                                                 }
   7647                                                               else
   7648                                                                 {
   7649                                                                   /* 33222222222211111111110000000000
   7650                                                                      10987654321098765432109876543210
   7651                                                                      000001x01010xxxx111x11xxxxxxxxxx
   7652                                                                      uqdecw.  */
   7653                                                                   return 1997;
   7654                                                                 }
   7655                                                             }
   7656                                                           else
   7657                                                             {
   7658                                                               if (((word >> 23) & 0x1) == 0)
   7659                                                                 {
   7660                                                                   /* 33222222222211111111110000000000
   7661                                                                      10987654321098765432109876543210
   7662                                                                      000001x00110xxxx111x11xxxxxxxxxx
   7663                                                                      uqdech.  */
   7664                                                                   return 1991;
   7665                                                                 }
   7666                                                               else
   7667                                                                 {
   7668                                                                   /* 33222222222211111111110000000000
   7669                                                                      10987654321098765432109876543210
   7670                                                                      000001x01110xxxx111x11xxxxxxxxxx
   7671                                                                      uqdecd.  */
   7672                                                                   return 1988;
   7673                                                                 }
   7674                                                             }
   7675                                                         }
   7676                                                       else
   7677                                                         {
   7678                                                           if (((word >> 22) & 0x1) == 0)
   7679                                                             {
   7680                                                               if (((word >> 23) & 0x1) == 0)
   7681                                                                 {
   7682                                                                   /* 33222222222211111111110000000000
   7683                                                                      10987654321098765432109876543210
   7684                                                                      000001x00011xxxx111x11xxxxxxxxxx
   7685                                                                      uqdecb.  */
   7686                                                                   return 1986;
   7687                                                                 }
   7688                                                               else
   7689                                                                 {
   7690                                                                   /* 33222222222211111111110000000000
   7691                                                                      10987654321098765432109876543210
   7692                                                                      000001x01011xxxx111x11xxxxxxxxxx
   7693                                                                      uqdecw.  */
   7694                                                                   return 1998;
   7695                                                                 }
   7696                                                             }
   7697                                                           else
   7698                                                             {
   7699                                                               if (((word >> 23) & 0x1) == 0)
   7700                                                                 {
   7701                                                                   /* 33222222222211111111110000000000
   7702                                                                      10987654321098765432109876543210
   7703                                                                      000001x00111xxxx111x11xxxxxxxxxx
   7704                                                                      uqdech.  */
   7705                                                                   return 1992;
   7706                                                                 }
   7707                                                               else
   7708                                                                 {
   7709                                                                   /* 33222222222211111111110000000000
   7710                                                                      10987654321098765432109876543210
   7711                                                                      000001x01111xxxx111x11xxxxxxxxxx
   7712                                                                      uqdecd.  */
   7713                                                                   return 1989;
   7714                                                                 }
   7715                                                             }
   7716                                                         }
   7717                                                     }
   7718                                                 }
   7719                                             }
   7720                                         }
   7721                                       else
   7722                                         {
   7723                                           if (((word >> 22) & 0x1) == 0)
   7724                                             {
   7725                                               if (((word >> 21) & 0x1) == 0)
   7726                                                 {
   7727                                                   if (((word >> 23) & 0x1) == 0)
   7728                                                     {
   7729                                                       /* 33222222222211111111110000000000
   7730                                                          10987654321098765432109876543210
   7731                                                          100001x0000xxxxx111xxxxxxxxxxxxx
   7732                                                          prfb.  */
   7733                                                       return 1771;
   7734                                                     }
   7735                                                   else
   7736                                                     {
   7737                                                       /* 33222222222211111111110000000000
   7738                                                          10987654321098765432109876543210
   7739                                                          100001x0100xxxxx111xxxxxxxxxxxxx
   7740                                                          prfh.  */
   7741                                                       return 1785;
   7742                                                     }
   7743                                                 }
   7744                                               else
   7745                                                 {
   7746                                                   if (((word >> 23) & 0x1) == 0)
   7747                                                     {
   7748                                                       /* 33222222222211111111110000000000
   7749                                                          10987654321098765432109876543210
   7750                                                          100001x0001xxxxx111xxxxxxxxxxxxx
   7751                                                          ldff1b.  */
   7752                                                       return 1639;
   7753                                                     }
   7754                                                   else
   7755                                                     {
   7756                                                       /* 33222222222211111111110000000000
   7757                                                          10987654321098765432109876543210
   7758                                                          100001x0101xxxxx111xxxxxxxxxxxxx
   7759                                                          ldff1h.  */
   7760                                                       return 1660;
   7761                                                     }
   7762                                                 }
   7763                                             }
   7764                                           else
   7765                                             {
   7766                                               if (((word >> 23) & 0x1) == 0)
   7767                                                 {
   7768                                                   /* 33222222222211111111110000000000
   7769                                                      10987654321098765432109876543210
   7770                                                      100001x001xxxxxx111xxxxxxxxxxxxx
   7771                                                      ld1rb.  */
   7772                                                   return 1541;
   7773                                                 }
   7774                                               else
   7775                                                 {
   7776                                                   /* 33222222222211111111110000000000
   7777                                                      10987654321098765432109876543210
   7778                                                      100001x011xxxxxx111xxxxxxxxxxxxx
   7779                                                      ld1rh.  */
   7780                                                   return 1545;
   7781                                                 }
   7782                                             }
   7783                                         }
   7784                                     }
   7785                                   else
   7786                                     {
   7787                                       if (((word >> 21) & 0x1) == 0)
   7788                                         {
   7789                                           if (((word >> 22) & 0x1) == 0)
   7790                                             {
   7791                                               if (((word >> 23) & 0x1) == 0)
   7792                                                 {
   7793                                                   /* 33222222222211111111110000000000
   7794                                                      10987654321098765432109876543210
   7795                                                      x10001x0000xxxxx111xxxxxxxxxxxxx
   7796                                                      prfb.  */
   7797                                                   return 1773;
   7798                                                 }
   7799                                               else
   7800                                                 {
   7801                                                   /* 33222222222211111111110000000000
   7802                                                      10987654321098765432109876543210
   7803                                                      x10001x0100xxxxx111xxxxxxxxxxxxx
   7804                                                      prfh.  */
   7805                                                   return 1787;
   7806                                                 }
   7807                                             }
   7808                                           else
   7809                                             {
   7810                                               if (((word >> 23) & 0x1) == 0)
   7811                                                 {
   7812                                                   /* 33222222222211111111110000000000
   7813                                                      10987654321098765432109876543210
   7814                                                      x10001x0010xxxxx111xxxxxxxxxxxxx
   7815                                                      ldff1b.  */
   7816                                                   return 1638;
   7817                                                 }
   7818                                               else
   7819                                                 {
   7820                                                   /* 33222222222211111111110000000000
   7821                                                      10987654321098765432109876543210
   7822                                                      x10001x0110xxxxx111xxxxxxxxxxxxx
   7823                                                      ldff1h.  */
   7824                                                   return 1658;
   7825                                                 }
   7826                                             }
   7827                                         }
   7828                                       else
   7829                                         {
   7830                                           if (((word >> 23) & 0x1) == 0)
   7831                                             {
   7832                                               if (((word >> 31) & 0x1) == 0)
   7833                                                 {
   7834                                                   if (((word >> 10) & 0x1) == 0)
   7835                                                     {
   7836                                                       if (((word >> 11) & 0x1) == 0)
   7837                                                         {
   7838                                                           /* 33222222222211111111110000000000
   7839                                                              10987654321098765432109876543210
   7840                                                              010001x00x1xxxxx111x00xxxxxxxxxx
   7841                                                              sqdmulh.  */
   7842                                                           return 2182;
   7843                                                         }
   7844                                                       else
   7845                                                         {
   7846                                                           /* 33222222222211111111110000000000
   7847                                                              10987654321098765432109876543210
   7848                                                              010001x00x1xxxxx111x10xxxxxxxxxx
   7849                                                              mul.  */
   7850                                                           return 2109;
   7851                                                         }
   7852                                                     }
   7853                                                   else
   7854                                                     {
   7855                                                       /* 33222222222211111111110000000000
   7856                                                          10987654321098765432109876543210
   7857                                                          010001x00x1xxxxx111xx1xxxxxxxxxx
   7858                                                          sqrdmulh.  */
   7859                                                       return 2204;
   7860                                                     }
   7861                                                 }
   7862                                               else
   7863                                                 {
   7864                                                   if (((word >> 22) & 0x1) == 0)
   7865                                                     {
   7866                                                       /* 33222222222211111111110000000000
   7867                                                          10987654321098765432109876543210
   7868                                                          110001x0001xxxxx111xxxxxxxxxxxxx
   7869                                                          ldff1b.  */
   7870                                                       return 1640;
   7871                                                     }
   7872                                                   else
   7873                                                     {
   7874                                                       /* 33222222222211111111110000000000
   7875                                                          10987654321098765432109876543210
   7876                                                          110001x0011xxxxx111xxxxxxxxxxxxx
   7877                                                          prfd.  */
   7878                                                       return 1777;
   7879                                                     }
   7880                                                 }
   7881                                             }
   7882                                           else
   7883                                             {
   7884                                               if (((word >> 22) & 0x1) == 0)
   7885                                                 {
   7886                                                   if (((word >> 31) & 0x1) == 0)
   7887                                                     {
   7888                                                       if (((word >> 10) & 0x1) == 0)
   7889                                                         {
   7890                                                           if (((word >> 12) & 0x1) == 0)
   7891                                                             {
   7892                                                               /* 33222222222211111111110000000000
   7893                                                                  10987654321098765432109876543210
   7894                                                                  010001x0101xxxxx1110x0xxxxxxxxxx
   7895                                                                  sqdmullb.  */
   7896                                                               return 2186;
   7897                                                             }
   7898                                                           else
   7899                                                             {
   7900                                                               if (((word >> 11) & 0x1) == 0)
   7901                                                                 {
   7902                                                                   /* 33222222222211111111110000000000
   7903                                                                      10987654321098765432109876543210
   7904                                                                      010001x0101xxxxx111100xxxxxxxxxx
   7905                                                                      sqdmulh.  */
   7906                                                                   return 2183;
   7907                                                                 }
   7908                                                               else
   7909                                                                 {
   7910                                                                   /* 33222222222211111111110000000000
   7911                                                                      10987654321098765432109876543210
   7912                                                                      010001x0101xxxxx111110xxxxxxxxxx
   7913                                                                      mul.  */
   7914                                                                   return 2110;
   7915                                                                 }
   7916                                                             }
   7917                                                         }
   7918                                                       else
   7919                                                         {
   7920                                                           if (((word >> 12) & 0x1) == 0)
   7921                                                             {
   7922                                                               /* 33222222222211111111110000000000
   7923                                                                  10987654321098765432109876543210
   7924                                                                  010001x0101xxxxx1110x1xxxxxxxxxx
   7925                                                                  sqdmullt.  */
   7926                                                               return 2189;
   7927                                                             }
   7928                                                           else
   7929                                                             {
   7930                                                               /* 33222222222211111111110000000000
   7931                                                                  10987654321098765432109876543210
   7932                                                                  010001x0101xxxxx1111x1xxxxxxxxxx
   7933                                                                  sqrdmulh.  */
   7934                                                               return 2205;
   7935                                                             }
   7936                                                         }
   7937                                                     }
   7938                                                   else
   7939                                                     {
   7940                                                       /* 33222222222211111111110000000000
   7941                                                          10987654321098765432109876543210
   7942                                                          110001x0101xxxxx111xxxxxxxxxxxxx
   7943                                                          ldff1h.  */
   7944                                                       return 1661;
   7945                                                     }
   7946                                                 }
   7947                                               else
   7948                                                 {
   7949                                                   if (((word >> 31) & 0x1) == 0)
   7950                                                     {
   7951                                                       if (((word >> 10) & 0x1) == 0)
   7952                                                         {
   7953                                                           if (((word >> 12) & 0x1) == 0)
   7954                                                             {
   7955                                                               /* 33222222222211111111110000000000
   7956                                                                  10987654321098765432109876543210
   7957                                                                  010001x0111xxxxx1110x0xxxxxxxxxx
   7958                                                                  sqdmullb.  */
   7959                                                               return 2187;
   7960                                                             }
   7961                                                           else
   7962                                                             {
   7963                                                               if (((word >> 11) & 0x1) == 0)
   7964                                                                 {
   7965                                                                   /* 33222222222211111111110000000000
   7966                                                                      10987654321098765432109876543210
   7967                                                                      010001x0111xxxxx111100xxxxxxxxxx
   7968                                                                      sqdmulh.  */
   7969                                                                   return 2184;
   7970                                                                 }
   7971                                                               else
   7972                                                                 {
   7973                                                                   /* 33222222222211111111110000000000
   7974                                                                      10987654321098765432109876543210
   7975                                                                      010001x0111xxxxx111110xxxxxxxxxx
   7976                                                                      mul.  */
   7977                                                                   return 2111;
   7978                                                                 }
   7979                                                             }
   7980                                                         }
   7981                                                       else
   7982                                                         {
   7983                                                           if (((word >> 12) & 0x1) == 0)
   7984                                                             {
   7985                                                               /* 33222222222211111111110000000000
   7986                                                                  10987654321098765432109876543210
   7987                                                                  010001x0111xxxxx1110x1xxxxxxxxxx
   7988                                                                  sqdmullt.  */
   7989                                                               return 2190;
   7990                                                             }
   7991                                                           else
   7992                                                             {
   7993                                                               /* 33222222222211111111110000000000
   7994                                                                  10987654321098765432109876543210
   7995                                                                  010001x0111xxxxx1111x1xxxxxxxxxx
   7996                                                                  sqrdmulh.  */
   7997                                                               return 2206;
   7998                                                             }
   7999                                                         }
   8000                                                     }
   8001                                                   else
   8002                                                     {
   8003                                                       /* 33222222222211111111110000000000
   8004                                                          10987654321098765432109876543210
   8005                                                          110001x0111xxxxx111xxxxxxxxxxxxx
   8006                                                          ldff1h.  */
   8007                                                       return 1659;
   8008                                                     }
   8009                                                 }
   8010                                             }
   8011                                         }
   8012                                     }
   8013                                 }
   8014                             }
   8015                         }
   8016                     }
   8017                   else
   8018                     {
   8019                       if (((word >> 21) & 0x1) == 0)
   8020                         {
   8021                           if (((word >> 15) & 0x1) == 0)
   8022                             {
   8023                               if (((word >> 30) & 0x1) == 0)
   8024                                 {
   8025                                   if (((word >> 13) & 0x1) == 0)
   8026                                     {
   8027                                       if (((word >> 14) & 0x1) == 0)
   8028                                         {
   8029                                           if (((word >> 31) & 0x1) == 0)
   8030                                             {
   8031                                               if (((word >> 4) & 0x1) == 0)
   8032                                                 {
   8033                                                   /* 33222222222211111111110000000000
   8034                                                      10987654321098765432109876543210
   8035                                                      001001x0xx0xxxxx000xxxxxxxx0xxxx
   8036                                                      cmphs.  */
   8037                                                   return 1333;
   8038                                                 }
   8039                                               else
   8040                                                 {
   8041                                                   /* 33222222222211111111110000000000
   8042                                                      10987654321098765432109876543210
   8043                                                      001001x0xx0xxxxx000xxxxxxxx1xxxx
   8044                                                      cmphi.  */
   8045                                                   return 1330;
   8046                                                 }
   8047                                             }
   8048                                           else
   8049                                             {
   8050                                               if (((word >> 23) & 0x1) == 0)
   8051                                                 {
   8052                                                   /* 33222222222211111111110000000000
   8053                                                      10987654321098765432109876543210
   8054                                                      101001x00x0xxxxx000xxxxxxxxxxxxx
   8055                                                      ld1rqb.  */
   8056                                                   return 1547;
   8057                                                 }
   8058                                               else
   8059                                                 {
   8060                                                   /* 33222222222211111111110000000000
   8061                                                      10987654321098765432109876543210
   8062                                                      101001x01x0xxxxx000xxxxxxxxxxxxx
   8063                                                      ld1rqh.  */
   8064                                                   return 1551;
   8065                                                 }
   8066                                             }
   8067                                         }
   8068                                       else
   8069                                         {
   8070                                           if (((word >> 31) & 0x1) == 0)
   8071                                             {
   8072                                               if (((word >> 4) & 0x1) == 0)
   8073                                                 {
   8074                                                   /* 33222222222211111111110000000000
   8075                                                      10987654321098765432109876543210
   8076                                                      001001x0xx0xxxxx010xxxxxxxx0xxxx
   8077                                                      cmpge.  */
   8078                                                   return 1324;
   8079                                                 }
   8080                                               else
   8081                                                 {
   8082                                                   /* 33222222222211111111110000000000
   8083                                                      10987654321098765432109876543210
   8084                                                      001001x0xx0xxxxx010xxxxxxxx1xxxx
   8085                                                      cmpgt.  */
   8086                                                   return 1327;
   8087                                                 }
   8088                                             }
   8089                                           else
   8090                                             {
   8091                                               if (((word >> 22) & 0x1) == 0)
   8092                                                 {
   8093                                                   if (((word >> 23) & 0x1) == 0)
   8094                                                     {
   8095                                                       /* 33222222222211111111110000000000
   8096                                                          10987654321098765432109876543210
   8097                                                          101001x0000xxxxx010xxxxxxxxxxxxx
   8098                                                          ld1b.  */
   8099                                                       return 1505;
   8100                                                     }
   8101                                                   else
   8102                                                     {
   8103                                                       /* 33222222222211111111110000000000
   8104                                                          10987654321098765432109876543210
   8105                                                          101001x0100xxxxx010xxxxxxxxxxxxx
   8106                                                          ld1sw.  */
   8107                                                       return 1585;
   8108                                                     }
   8109                                                 }
   8110                                               else
   8111                                                 {
   8112                                                   if (((word >> 23) & 0x1) == 0)
   8113                                                     {
   8114                                                       /* 33222222222211111111110000000000
   8115                                                          10987654321098765432109876543210
   8116                                                          101001x0010xxxxx010xxxxxxxxxxxxx
   8117                                                          ld1b.  */
   8118                                                       return 1507;
   8119                                                     }
   8120                                                   else
   8121                                                     {
   8122                                                       /* 33222222222211111111110000000000
   8123                                                          10987654321098765432109876543210
   8124                                                          101001x0110xxxxx010xxxxxxxxxxxxx
   8125                                                          ld1h.  */
   8126                                                       return 1527;
   8127                                                     }
   8128                                                 }
   8129                                             }
   8130                                         }
   8131                                     }
   8132                                   else
   8133                                     {
   8134                                       if (((word >> 14) & 0x1) == 0)
   8135                                         {
   8136                                           if (((word >> 31) & 0x1) == 0)
   8137                                             {
   8138                                               if (((word >> 4) & 0x1) == 0)
   8139                                                 {
   8140                                                   /* 33222222222211111111110000000000
   8141                                                      10987654321098765432109876543210
   8142                                                      001001x0xx0xxxxx001xxxxxxxx0xxxx
   8143                                                      cmpeq.  */
   8144                                                   return 1321;
   8145                                                 }
   8146                                               else
   8147                                                 {
   8148                                                   /* 33222222222211111111110000000000
   8149                                                      10987654321098765432109876543210
   8150                                                      001001x0xx0xxxxx001xxxxxxxx1xxxx
   8151                                                      cmpne.  */
   8152                                                   return 1344;
   8153                                                 }
   8154                                             }
   8155                                           else
   8156                                             {
   8157                                               if (((word >> 23) & 0x1) == 0)
   8158                                                 {
   8159                                                   /* 33222222222211111111110000000000
   8160                                                      10987654321098765432109876543210
   8161                                                      101001x00x0xxxxx001xxxxxxxxxxxxx
   8162                                                      ld1rqb.  */
   8163                                                   return 1546;
   8164                                                 }
   8165                                               else
   8166                                                 {
   8167                                                   /* 33222222222211111111110000000000
   8168                                                      10987654321098765432109876543210
   8169                                                      101001x01x0xxxxx001xxxxxxxxxxxxx
   8170                                                      ld1rqh.  */
   8171                                                   return 1550;
   8172                                                 }
   8173                                             }
   8174                                         }
   8175                                       else
   8176                                         {
   8177                                           if (((word >> 31) & 0x1) == 0)
   8178                                             {
   8179                                               if (((word >> 4) & 0x1) == 0)
   8180                                                 {
   8181                                                   /* 33222222222211111111110000000000
   8182                                                      10987654321098765432109876543210
   8183                                                      001001x0xx0xxxxx011xxxxxxxx0xxxx
   8184                                                      cmplt.  */
   8185                                                   return 1342;
   8186                                                 }
   8187                                               else
   8188                                                 {
   8189                                                   /* 33222222222211111111110000000000
   8190                                                      10987654321098765432109876543210
   8191                                                      001001x0xx0xxxxx011xxxxxxxx1xxxx
   8192                                                      cmple.  */
   8193                                                   return 1336;
   8194                                                 }
   8195                                             }
   8196                                           else
   8197                                             {
   8198                                               if (((word >> 22) & 0x1) == 0)
   8199                                                 {
   8200                                                   if (((word >> 23) & 0x1) == 0)
   8201                                                     {
   8202                                                       /* 33222222222211111111110000000000
   8203                                                          10987654321098765432109876543210
   8204                                                          101001x0000xxxxx011xxxxxxxxxxxxx
   8205                                                          ldff1b.  */
   8206                                                       return 1629;
   8207                                                     }
   8208                                                   else
   8209                                                     {
   8210                                                       /* 33222222222211111111110000000000
   8211                                                          10987654321098765432109876543210
   8212                                                          101001x0100xxxxx011xxxxxxxxxxxxx
   8213                                                          ldff1sw.  */
   8214                                                       return 1685;
   8215                                                     }
   8216                                                 }
   8217                                               else
   8218                                                 {
   8219                                                   if (((word >> 23) & 0x1) == 0)
   8220                                                     {
   8221                                                       /* 33222222222211111111110000000000
   8222                                                          10987654321098765432109876543210
   8223                                                          101001x0010xxxxx011xxxxxxxxxxxxx
   8224                                                          ldff1b.  */
   8225                                                       return 1633;
   8226                                                     }
   8227                                                   else
   8228                                                     {
   8229                                                       /* 33222222222211111111110000000000
   8230                                                          10987654321098765432109876543210
   8231                                                          101001x0110xxxxx011xxxxxxxxxxxxx
   8232                                                          ldff1h.  */
   8233                                                       return 1652;
   8234                                                     }
   8235                                                 }
   8236                                             }
   8237                                         }
   8238                                     }
   8239                                 }
   8240                               else
   8241                                 {
   8242                                   if (((word >> 31) & 0x1) == 0)
   8243                                     {
   8244                                       /* 33222222222211111111110000000000
   8245                                          10987654321098765432109876543210
   8246                                          011001x0xx0xxxxx0xxxxxxxxxxxxxxx
   8247                                          fcmla.  */
   8248                                       return 1390;
   8249                                     }
   8250                                   else
   8251                                     {
   8252                                       if (((word >> 13) & 0x1) == 0)
   8253                                         {
   8254                                           if (((word >> 22) & 0x1) == 0)
   8255                                             {
   8256                                               /* 33222222222211111111110000000000
   8257                                                  10987654321098765432109876543210
   8258                                                  111001x0x00xxxxx0x0xxxxxxxxxxxxx
   8259                                                  st1b.  */
   8260                                               return 1867;
   8261                                             }
   8262                                           else
   8263                                             {
   8264                                               if (((word >> 23) & 0x1) == 0)
   8265                                                 {
   8266                                                   /* 33222222222211111111110000000000
   8267                                                      10987654321098765432109876543210
   8268                                                      111001x0010xxxxx0x0xxxxxxxxxxxxx
   8269                                                      st1b.  */
   8270                                                   return 1871;
   8271                                                 }
   8272                                               else
   8273                                                 {
   8274                                                   /* 33222222222211111111110000000000
   8275                                                      10987654321098765432109876543210
   8276                                                      111001x0110xxxxx0x0xxxxxxxxxxxxx
   8277                                                      st1h.  */
   8278                                                   return 1892;
   8279                                                 }
   8280                                             }
   8281                                         }
   8282                                       else
   8283                                         {
   8284                                           if (((word >> 14) & 0x1) == 0)
   8285                                             {
   8286                                               if (((word >> 22) & 0x1) == 0)
   8287                                                 {
   8288                                                   if (((word >> 23) & 0x1) == 0)
   8289                                                     {
   8290                                                       /* 33222222222211111111110000000000
   8291                                                          10987654321098765432109876543210
   8292                                                          111001x0000xxxxx001xxxxxxxxxxxxx
   8293                                                          stnt1b.  */
   8294                                                       return 2244;
   8295                                                     }
   8296                                                   else
   8297                                                     {
   8298                                                       /* 33222222222211111111110000000000
   8299                                                          10987654321098765432109876543210
   8300                                                          111001x0100xxxxx001xxxxxxxxxxxxx
   8301                                                          stnt1h.  */
   8302                                                       return 2247;
   8303                                                     }
   8304                                                 }
   8305                                               else
   8306                                                 {
   8307                                                   if (((word >> 23) & 0x1) == 0)
   8308                                                     {
   8309                                                       /* 33222222222211111111110000000000
   8310                                                          10987654321098765432109876543210
   8311                                                          111001x0010xxxxx001xxxxxxxxxxxxx
   8312                                                          stnt1b.  */
   8313                                                       return 2243;
   8314                                                     }
   8315                                                   else
   8316                                                     {
   8317                                                       /* 33222222222211111111110000000000
   8318                                                          10987654321098765432109876543210
   8319                                                          111001x0110xxxxx001xxxxxxxxxxxxx
   8320                                                          stnt1h.  */
   8321                                                       return 2246;
   8322                                                     }
   8323                                                 }
   8324                                             }
   8325                                           else
   8326                                             {
   8327                                               if (((word >> 22) & 0x1) == 0)
   8328                                                 {
   8329                                                   if (((word >> 23) & 0x1) == 0)
   8330                                                     {
   8331                                                       /* 33222222222211111111110000000000
   8332                                                          10987654321098765432109876543210
   8333                                                          111001x0000xxxxx011xxxxxxxxxxxxx
   8334                                                          stnt1b.  */
   8335                                                       return 1937;
   8336                                                     }
   8337                                                   else
   8338                                                     {
   8339                                                       /* 33222222222211111111110000000000
   8340                                                          10987654321098765432109876543210
   8341                                                          111001x0100xxxxx011xxxxxxxxxxxxx
   8342                                                          stnt1h.  */
   8343                                                       return 1941;
   8344                                                     }
   8345                                                 }
   8346                                               else
   8347                                                 {
   8348                                                   if (((word >> 23) & 0x1) == 0)
   8349                                                     {
   8350                                                       /* 33222222222211111111110000000000
   8351                                                          10987654321098765432109876543210
   8352                                                          111001x0010xxxxx011xxxxxxxxxxxxx
   8353                                                          st3b.  */
   8354                                                       return 1921;
   8355                                                     }
   8356                                                   else
   8357                                                     {
   8358                                                       /* 33222222222211111111110000000000
   8359                                                          10987654321098765432109876543210
   8360                                                          111001x0110xxxxx011xxxxxxxxxxxxx
   8361                                                          st3h.  */
   8362                                                       return 1925;
   8363                                                     }
   8364                                                 }
   8365                                             }
   8366                                         }
   8367                                     }
   8368                                 }
   8369                             }
   8370                           else
   8371                             {
   8372                               if (((word >> 13) & 0x1) == 0)
   8373                                 {
   8374                                   if (((word >> 30) & 0x1) == 0)
   8375                                     {
   8376                                       if (((word >> 14) & 0x1) == 0)
   8377                                         {
   8378                                           if (((word >> 4) & 0x1) == 0)
   8379                                             {
   8380                                               /* 33222222222211111111110000000000
   8381                                                  10987654321098765432109876543210
   8382                                                  x01001x0xx0xxxxx100xxxxxxxx0xxxx
   8383                                                  cmpge.  */
   8384                                               return 1325;
   8385                                             }
   8386                                           else
   8387                                             {
   8388                                               /* 33222222222211111111110000000000
   8389                                                  10987654321098765432109876543210
   8390                                                  x01001x0xx0xxxxx100xxxxxxxx1xxxx
   8391                                                  cmpgt.  */
   8392                                               return 1328;
   8393                                             }
   8394                                         }
   8395                                       else
   8396                                         {
   8397                                           if (((word >> 31) & 0x1) == 0)
   8398                                             {
   8399                                               if (((word >> 4) & 0x1) == 0)
   8400                                                 {
   8401                                                   /* 33222222222211111111110000000000
   8402                                                      10987654321098765432109876543210
   8403                                                      001001x0xx0xxxxx110xxxxxxxx0xxxx
   8404                                                      cmphs.  */
   8405                                                   return 1334;
   8406                                                 }
   8407                                               else
   8408                                                 {
   8409                                                   /* 33222222222211111111110000000000
   8410                                                      10987654321098765432109876543210
   8411                                                      001001x0xx0xxxxx110xxxxxxxx1xxxx
   8412                                                      cmphi.  */
   8413                                                   return 1331;
   8414                                                 }
   8415                                             }
   8416                                           else
   8417                                             {
   8418                                               if (((word >> 22) & 0x1) == 0)
   8419                                                 {
   8420                                                   if (((word >> 23) & 0x1) == 0)
   8421                                                     {
   8422                                                       /* 33222222222211111111110000000000
   8423                                                          10987654321098765432109876543210
   8424                                                          101001x0000xxxxx110xxxxxxxxxxxxx
   8425                                                          ldnt1b.  */
   8426                                                       return 1720;
   8427                                                     }
   8428                                                   else
   8429                                                     {
   8430                                                       /* 33222222222211111111110000000000
   8431                                                          10987654321098765432109876543210
   8432                                                          101001x0100xxxxx110xxxxxxxxxxxxx
   8433                                                          ldnt1h.  */
   8434                                                       return 1724;
   8435                                                     }
   8436                                                 }
   8437                                               else
   8438                                                 {
   8439                                                   if (((word >> 23) & 0x1) == 0)
   8440                                                     {
   8441                                                       /* 33222222222211111111110000000000
   8442                                                          10987654321098765432109876543210
   8443                                                          101001x0010xxxxx110xxxxxxxxxxxxx
   8444                                                          ld3b.  */
   8445                                                       return 1612;
   8446                                                     }
   8447                                                   else
   8448                                                     {
   8449                                                       /* 33222222222211111111110000000000
   8450                                                          10987654321098765432109876543210
   8451                                                          101001x0110xxxxx110xxxxxxxxxxxxx
   8452                                                          ld3h.  */
   8453                                                       return 1616;
   8454                                                     }
   8455                                                 }
   8456                                             }
   8457                                         }
   8458                                     }
   8459                                   else
   8460                                     {
   8461                                       if (((word >> 31) & 0x1) == 0)
   8462                                         {
   8463                                           if (((word >> 17) & 0x1) == 0)
   8464                                             {
   8465                                               if (((word >> 18) & 0x1) == 0)
   8466                                                 {
   8467                                                   if (((word >> 20) & 0x1) == 0)
   8468                                                     {
   8469                                                       /* 33222222222211111111110000000000
   8470                                                          10987654321098765432109876543210
   8471                                                          011001x0xx00x00x1x0xxxxxxxxxxxxx
   8472                                                          fcadd.  */
   8473                                                       return 1389;
   8474                                                     }
   8475                                                   else
   8476                                                     {
   8477                                                       /* 33222222222211111111110000000000
   8478                                                          10987654321098765432109876543210
   8479                                                          011001x0xx01x00x1x0xxxxxxxxxxxxx
   8480                                                          faddp.  */
   8481                                                       return 2070;
   8482                                                     }
   8483                                                 }
   8484                                               else
   8485                                                 {
   8486                                                   if (((word >> 16) & 0x1) == 0)
   8487                                                     {
   8488                                                       /* 33222222222211111111110000000000
   8489                                                          10987654321098765432109876543210
   8490                                                          011001x0xx0xx1001x0xxxxxxxxxxxxx
   8491                                                          fmaxnmp.  */
   8492                                                       return 2078;
   8493                                                     }
   8494                                                   else
   8495                                                     {
   8496                                                       /* 33222222222211111111110000000000
   8497                                                          10987654321098765432109876543210
   8498                                                          011001x0xx0xx1011x0xxxxxxxxxxxxx
   8499                                                          fminnmp.  */
   8500                                                       return 2080;
   8501                                                     }
   8502                                                 }
   8503                                             }
   8504                                           else
   8505                                             {
   8506                                               if (((word >> 16) & 0x1) == 0)
   8507                                                 {
   8508                                                   /* 33222222222211111111110000000000
   8509                                                      10987654321098765432109876543210
   8510                                                      011001x0xx0xxx101x0xxxxxxxxxxxxx
   8511                                                      fmaxp.  */
   8512                                                   return 2079;
   8513                                                 }
   8514                                               else
   8515                                                 {
   8516                                                   /* 33222222222211111111110000000000
   8517                                                      10987654321098765432109876543210
   8518                                                      011001x0xx0xxx111x0xxxxxxxxxxxxx
   8519                                                      fminp.  */
   8520                                                   return 2081;
   8521                                                 }
   8522                                             }
   8523                                         }
   8524                                       else
   8525                                         {
   8526                                           if (((word >> 22) & 0x1) == 0)
   8527                                             {
   8528                                               if (((word >> 23) & 0x1) == 0)
   8529                                                 {
   8530                                                   /* 33222222222211111111110000000000
   8531                                                      10987654321098765432109876543210
   8532                                                      111001x0000xxxxx1x0xxxxxxxxxxxxx
   8533                                                      st1b.  */
   8534                                                   return 1868;
   8535                                                 }
   8536                                               else
   8537                                                 {
   8538                                                   /* 33222222222211111111110000000000
   8539                                                      10987654321098765432109876543210
   8540                                                      111001x0100xxxxx1x0xxxxxxxxxxxxx
   8541                                                      st1h.  */
   8542                                                   return 1887;
   8543                                                 }
   8544                                             }
   8545                                           else
   8546                                             {
   8547                                               if (((word >> 23) & 0x1) == 0)
   8548                                                 {
   8549                                                   /* 33222222222211111111110000000000
   8550                                                      10987654321098765432109876543210
   8551                                                      111001x0010xxxxx1x0xxxxxxxxxxxxx
   8552                                                      st1b.  */
   8553                                                   return 1872;
   8554                                                 }
   8555                                               else
   8556                                                 {
   8557                                                   /* 33222222222211111111110000000000
   8558                                                      10987654321098765432109876543210
   8559                                                      111001x0110xxxxx1x0xxxxxxxxxxxxx
   8560                                                      st1h.  */
   8561                                                   return 1893;
   8562                                                 }
   8563                                             }
   8564                                         }
   8565                                     }
   8566                                 }
   8567                               else
   8568                                 {
   8569                                   if (((word >> 14) & 0x1) == 0)
   8570                                     {
   8571                                       if (((word >> 30) & 0x1) == 0)
   8572                                         {
   8573                                           if (((word >> 31) & 0x1) == 0)
   8574                                             {
   8575                                               if (((word >> 4) & 0x1) == 0)
   8576                                                 {
   8577                                                   /* 33222222222211111111110000000000
   8578                                                      10987654321098765432109876543210
   8579                                                      001001x0xx0xxxxx101xxxxxxxx0xxxx
   8580                                                      cmpeq.  */
   8581                                                   return 1322;
   8582                                                 }
   8583                                               else
   8584                                                 {
   8585                                                   /* 33222222222211111111110000000000
   8586                                                      10987654321098765432109876543210
   8587                                                      001001x0xx0xxxxx101xxxxxxxx1xxxx
   8588                                                      cmpne.  */
   8589                                                   return 1345;
   8590                                                 }
   8591                                             }
   8592                                           else
   8593                                             {
   8594                                               if (((word >> 20) & 0x1) == 0)
   8595                                                 {
   8596                                                   if (((word >> 22) & 0x1) == 0)
   8597                                                     {
   8598                                                       if (((word >> 23) & 0x1) == 0)
   8599                                                         {
   8600                                                           /* 33222222222211111111110000000000
   8601                                                              10987654321098765432109876543210
   8602                                                              101001x00000xxxx101xxxxxxxxxxxxx
   8603                                                              ld1b.  */
   8604                                                           return 1512;
   8605                                                         }
   8606                                                       else
   8607                                                         {
   8608                                                           /* 33222222222211111111110000000000
   8609                                                              10987654321098765432109876543210
   8610                                                              101001x01000xxxx101xxxxxxxxxxxxx
   8611                                                              ld1sw.  */
   8612                                                           return 1590;
   8613                                                         }
   8614                                                     }
   8615                                                   else
   8616                                                     {
   8617                                                       if (((word >> 23) & 0x1) == 0)
   8618                                                         {
   8619                                                           /* 33222222222211111111110000000000
   8620                                                              10987654321098765432109876543210
   8621                                                              101001x00100xxxx101xxxxxxxxxxxxx
   8622                                                              ld1b.  */
   8623                                                           return 1514;
   8624                                                         }
   8625                                                       else
   8626                                                         {
   8627                                                           /* 33222222222211111111110000000000
   8628                                                              10987654321098765432109876543210
   8629                                                              101001x01100xxxx101xxxxxxxxxxxxx
   8630                                                              ld1h.  */
   8631                                                           return 1535;
   8632                                                         }
   8633                                                     }
   8634                                                 }
   8635                                               else
   8636                                                 {
   8637                                                   if (((word >> 22) & 0x1) == 0)
   8638                                                     {
   8639                                                       if (((word >> 23) & 0x1) == 0)
   8640                                                         {
   8641                                                           /* 33222222222211111111110000000000
   8642                                                              10987654321098765432109876543210
   8643                                                              101001x00001xxxx101xxxxxxxxxxxxx
   8644                                                              ldnf1b.  */
   8645                                                           return 1704;
   8646                                                         }
   8647                                                       else
   8648                                                         {
   8649                                                           /* 33222222222211111111110000000000
   8650                                                              10987654321098765432109876543210
   8651                                                              101001x01001xxxx101xxxxxxxxxxxxx
   8652                                                              ldnf1sw.  */
   8653                                                           return 1717;
   8654                                                         }
   8655                                                     }
   8656                                                   else
   8657                                                     {
   8658                                                       if (((word >> 23) & 0x1) == 0)
   8659                                                         {
   8660                                                           /* 33222222222211111111110000000000
   8661                                                              10987654321098765432109876543210
   8662                                                              101001x00101xxxx101xxxxxxxxxxxxx
   8663                                                              ldnf1b.  */
   8664                                                           return 1706;
   8665                                                         }
   8666                                                       else
   8667                                                         {
   8668                                                           /* 33222222222211111111110000000000
   8669                                                              10987654321098765432109876543210
   8670                                                              101001x01101xxxx101xxxxxxxxxxxxx
   8671                                                              ldnf1h.  */
   8672                                                           return 1710;
   8673                                                         }
   8674                                                     }
   8675                                                 }
   8676                                             }
   8677                                         }
   8678                                       else
   8679                                         {
   8680                                           if (((word >> 22) & 0x1) == 0)
   8681                                             {
   8682                                               if (((word >> 23) & 0x1) == 0)
   8683                                                 {
   8684                                                   if (((word >> 31) & 0x1) == 0)
   8685                                                     {
   8686                                                       /* 33222222222211111111110000000000
   8687                                                          10987654321098765432109876543210
   8688                                                          011001x0000xxxxx101xxxxxxxxxxxxx
   8689                                                          fcvtxnt.  */
   8690                                                       return 2076;
   8691                                                     }
   8692                                                   else
   8693                                                     {
   8694                                                       /* 33222222222211111111110000000000
   8695                                                          10987654321098765432109876543210
   8696                                                          111001x0000xxxxx101xxxxxxxxxxxxx
   8697                                                          st1b.  */
   8698                                                       return 1869;
   8699                                                     }
   8700                                                 }
   8701                                               else
   8702                                                 {
   8703                                                   if (((word >> 31) & 0x1) == 0)
   8704                                                     {
   8705                                                       if (((word >> 16) & 0x1) == 0)
   8706                                                         {
   8707                                                           if (((word >> 17) & 0x1) == 0)
   8708                                                             {
   8709                                                               /* 33222222222211111111110000000000
   8710                                                                  10987654321098765432109876543210
   8711                                                                  011001x0100xxx00101xxxxxxxxxxxxx
   8712                                                                  fcvtnt.  */
   8713                                                               return 2073;
   8714                                                             }
   8715                                                           else
   8716                                                             {
   8717                                                               /* 33222222222211111111110000000000
   8718                                                                  10987654321098765432109876543210
   8719                                                                  011001x0100xxx10101xxxxxxxxxxxxx
   8720                                                                  bfcvtnt.  */
   8721                                                               return 2426;
   8722                                                             }
   8723                                                         }
   8724                                                       else
   8725                                                         {
   8726                                                           /* 33222222222211111111110000000000
   8727                                                              10987654321098765432109876543210
   8728                                                              011001x0100xxxx1101xxxxxxxxxxxxx
   8729                                                              fcvtlt.  */
   8730                                                           return 2071;
   8731                                                         }
   8732                                                     }
   8733                                                   else
   8734                                                     {
   8735                                                       /* 33222222222211111111110000000000
   8736                                                          10987654321098765432109876543210
   8737                                                          111001x0100xxxxx101xxxxxxxxxxxxx
   8738                                                          st1h.  */
   8739                                                       return 1888;
   8740                                                     }
   8741                                                 }
   8742                                             }
   8743                                           else
   8744                                             {
   8745                                               if (((word >> 23) & 0x1) == 0)
   8746                                                 {
   8747                                                   /* 33222222222211111111110000000000
   8748                                                      10987654321098765432109876543210
   8749                                                      x11001x0010xxxxx101xxxxxxxxxxxxx
   8750                                                      st1b.  */
   8751                                                   return 1876;
   8752                                                 }
   8753                                               else
   8754                                                 {
   8755                                                   if (((word >> 31) & 0x1) == 0)
   8756                                                     {
   8757                                                       if (((word >> 16) & 0x1) == 0)
   8758                                                         {
   8759                                                           /* 33222222222211111111110000000000
   8760                                                              10987654321098765432109876543210
   8761                                                              011001x0110xxxx0101xxxxxxxxxxxxx
   8762                                                              fcvtnt.  */
   8763                                                           return 2074;
   8764                                                         }
   8765                                                       else
   8766                                                         {
   8767                                                           /* 33222222222211111111110000000000
   8768                                                              10987654321098765432109876543210
   8769                                                              011001x0110xxxx1101xxxxxxxxxxxxx
   8770                                                              fcvtlt.  */
   8771                                                           return 2072;
   8772                                                         }
   8773                                                     }
   8774                                                   else
   8775                                                     {
   8776                                                       /* 33222222222211111111110000000000
   8777                                                          10987654321098765432109876543210
   8778                                                          111001x0110xxxxx101xxxxxxxxxxxxx
   8779                                                          st1h.  */
   8780                                                       return 1897;
   8781                                                     }
   8782                                                 }
   8783                                             }
   8784                                         }
   8785                                     }
   8786                                   else
   8787                                     {
   8788                                       if (((word >> 30) & 0x1) == 0)
   8789                                         {
   8790                                           if (((word >> 31) & 0x1) == 0)
   8791                                             {
   8792                                               if (((word >> 4) & 0x1) == 0)
   8793                                                 {
   8794                                                   /* 33222222222211111111110000000000
   8795                                                      10987654321098765432109876543210
   8796                                                      001001x0xx0xxxxx111xxxxxxxx0xxxx
   8797                                                      cmplo.  */
   8798                                                   return 1338;
   8799                                                 }
   8800                                               else
   8801                                                 {
   8802                                                   /* 33222222222211111111110000000000
   8803                                                      10987654321098765432109876543210
   8804                                                      001001x0xx0xxxxx111xxxxxxxx1xxxx
   8805                                                      cmpls.  */
   8806                                                   return 1340;
   8807                                                 }
   8808                                             }
   8809                                           else
   8810                                             {
   8811                                               if (((word >> 22) & 0x1) == 0)
   8812                                                 {
   8813                                                   if (((word >> 23) & 0x1) == 0)
   8814                                                     {
   8815                                                       /* 33222222222211111111110000000000
   8816                                                          10987654321098765432109876543210
   8817                                                          101001x0000xxxxx111xxxxxxxxxxxxx
   8818                                                          ldnt1b.  */
   8819                                                       return 1721;
   8820                                                     }
   8821                                                   else
   8822                                                     {
   8823                                                       /* 33222222222211111111110000000000
   8824                                                          10987654321098765432109876543210
   8825                                                          101001x0100xxxxx111xxxxxxxxxxxxx
   8826                                                          ldnt1h.  */
   8827                                                       return 1725;
   8828                                                     }
   8829                                                 }
   8830                                               else
   8831                                                 {
   8832                                                   if (((word >> 23) & 0x1) == 0)
   8833                                                     {
   8834                                                       /* 33222222222211111111110000000000
   8835                                                          10987654321098765432109876543210
   8836                                                          101001x0010xxxxx111xxxxxxxxxxxxx
   8837                                                          ld3b.  */
   8838                                                       return 1613;
   8839                                                     }
   8840                                                   else
   8841                                                     {
   8842                                                       /* 33222222222211111111110000000000
   8843                                                          10987654321098765432109876543210
   8844                                                          101001x0110xxxxx111xxxxxxxxxxxxx
   8845                                                          ld3h.  */
   8846                                                       return 1617;
   8847                                                     }
   8848                                                 }
   8849                                             }
   8850                                         }
   8851                                       else
   8852                                         {
   8853                                           if (((word >> 20) & 0x1) == 0)
   8854                                             {
   8855                                               if (((word >> 22) & 0x1) == 0)
   8856                                                 {
   8857                                                   /* 33222222222211111111110000000000
   8858                                                      10987654321098765432109876543210
   8859                                                      x11001x0x000xxxx111xxxxxxxxxxxxx
   8860                                                      st1b.  */
   8861                                                   return 1874;
   8862                                                 }
   8863                                               else
   8864                                                 {
   8865                                                   if (((word >> 23) & 0x1) == 0)
   8866                                                     {
   8867                                                       /* 33222222222211111111110000000000
   8868                                                          10987654321098765432109876543210
   8869                                                          x11001x00100xxxx111xxxxxxxxxxxxx
   8870                                                          st1b.  */
   8871                                                       return 1877;
   8872                                                     }
   8873                                                   else
   8874                                                     {
   8875                                                       /* 33222222222211111111110000000000
   8876                                                          10987654321098765432109876543210
   8877                                                          x11001x01100xxxx111xxxxxxxxxxxxx
   8878                                                          st1h.  */
   8879                                                       return 1898;
   8880                                                     }
   8881                                                 }
   8882                                             }
   8883                                           else
   8884                                             {
   8885                                               if (((word >> 22) & 0x1) == 0)
   8886                                                 {
   8887                                                   if (((word >> 23) & 0x1) == 0)
   8888                                                     {
   8889                                                       /* 33222222222211111111110000000000
   8890                                                          10987654321098765432109876543210
   8891                                                          x11001x00001xxxx111xxxxxxxxxxxxx
   8892                                                          stnt1b.  */
   8893                                                       return 1938;
   8894                                                     }
   8895                                                   else
   8896                                                     {
   8897                                                       /* 33222222222211111111110000000000
   8898                                                          10987654321098765432109876543210
   8899                                                          x11001x01001xxxx111xxxxxxxxxxxxx
   8900                                                          stnt1h.  */
   8901                                                       return 1942;
   8902                                                     }
   8903                                                 }
   8904                                               else
   8905                                                 {
   8906                                                   if (((word >> 23) & 0x1) == 0)
   8907                                                     {
   8908                                                       /* 33222222222211111111110000000000
   8909                                                          10987654321098765432109876543210
   8910                                                          x11001x00101xxxx111xxxxxxxxxxxxx
   8911                                                          st3b.  */
   8912                                                       return 1922;
   8913                                                     }
   8914                                                   else
   8915                                                     {
   8916                                                       /* 33222222222211111111110000000000
   8917                                                          10987654321098765432109876543210
   8918                                                          x11001x01101xxxx111xxxxxxxxxxxxx
   8919                                                          st3h.  */
   8920                                                       return 1926;
   8921                                                     }
   8922                                                 }
   8923                                             }
   8924                                         }
   8925                                     }
   8926                                 }
   8927                             }
   8928                         }
   8929                       else
   8930                         {
   8931                           if (((word >> 13) & 0x1) == 0)
   8932                             {
   8933                               if (((word >> 30) & 0x1) == 0)
   8934                                 {
   8935                                   if (((word >> 31) & 0x1) == 0)
   8936                                     {
   8937                                       if (((word >> 4) & 0x1) == 0)
   8938                                         {
   8939                                           /* 33222222222211111111110000000000
   8940                                              10987654321098765432109876543210
   8941                                              001001x0xx1xxxxxxx0xxxxxxxx0xxxx
   8942                                              cmphs.  */
   8943                                           return 1335;
   8944                                         }
   8945                                       else
   8946                                         {
   8947                                           /* 33222222222211111111110000000000
   8948                                              10987654321098765432109876543210
   8949                                              001001x0xx1xxxxxxx0xxxxxxxx1xxxx
   8950                                              cmphi.  */
   8951                                           return 1332;
   8952                                         }
   8953                                     }
   8954                                   else
   8955                                     {
   8956                                       if (((word >> 14) & 0x1) == 0)
   8957                                         {
   8958                                           if (((word >> 23) & 0x1) == 0)
   8959                                             {
   8960                                               /* 33222222222211111111110000000000
   8961                                                  10987654321098765432109876543210
   8962                                                  101001x00x1xxxxxx00xxxxxxxxxxxxx
   8963                                                  ld1rob.  */
   8964                                               return 2402;
   8965                                             }
   8966                                           else
   8967                                             {
   8968                                               /* 33222222222211111111110000000000
   8969                                                  10987654321098765432109876543210
   8970                                                  101001x01x1xxxxxx00xxxxxxxxxxxxx
   8971                                                  ld1roh.  */
   8972                                               return 2403;
   8973                                             }
   8974                                         }
   8975                                       else
   8976                                         {
   8977                                           if (((word >> 15) & 0x1) == 0)
   8978                                             {
   8979                                               if (((word >> 22) & 0x1) == 0)
   8980                                                 {
   8981                                                   if (((word >> 23) & 0x1) == 0)
   8982                                                     {
   8983                                                       /* 33222222222211111111110000000000
   8984                                                          10987654321098765432109876543210
   8985                                                          101001x0001xxxxx010xxxxxxxxxxxxx
   8986                                                          ld1b.  */
   8987                                                       return 1506;
   8988                                                     }
   8989                                                   else
   8990                                                     {
   8991                                                       /* 33222222222211111111110000000000
   8992                                                          10987654321098765432109876543210
   8993                                                          101001x0101xxxxx010xxxxxxxxxxxxx
   8994                                                          ld1h.  */
   8995                                                       return 1526;
   8996                                                     }
   8997                                                 }
   8998                                               else
   8999                                                 {
   9000                                                   if (((word >> 23) & 0x1) == 0)
   9001                                                     {
   9002                                                       /* 33222222222211111111110000000000
   9003                                                          10987654321098765432109876543210
   9004                                                          101001x0011xxxxx010xxxxxxxxxxxxx
   9005                                                          ld1b.  */
   9006                                                       return 1508;
   9007                                                     }
   9008                                                   else
   9009                                                     {
   9010                                                       /* 33222222222211111111110000000000
   9011                                                          10987654321098765432109876543210
   9012                                                          101001x0111xxxxx010xxxxxxxxxxxxx
   9013                                                          ld1h.  */
   9014                                                       return 1528;
   9015                                                     }
   9016                                                 }
   9017                                             }
   9018                                           else
   9019                                             {
   9020                                               if (((word >> 22) & 0x1) == 0)
   9021                                                 {
   9022                                                   if (((word >> 23) & 0x1) == 0)
   9023                                                     {
   9024                                                       /* 33222222222211111111110000000000
   9025                                                          10987654321098765432109876543210
   9026                                                          101001x0001xxxxx110xxxxxxxxxxxxx
   9027                                                          ld2b.  */
   9028                                                       return 1604;
   9029                                                     }
   9030                                                   else
   9031                                                     {
   9032                                                       /* 33222222222211111111110000000000
   9033                                                          10987654321098765432109876543210
   9034                                                          101001x0101xxxxx110xxxxxxxxxxxxx
   9035                                                          ld2h.  */
   9036                                                       return 1608;
   9037                                                     }
   9038                                                 }
   9039                                               else
   9040                                                 {
   9041                                                   if (((word >> 23) & 0x1) == 0)
   9042                                                     {
   9043                                                       /* 33222222222211111111110000000000
   9044                                                          10987654321098765432109876543210
   9045                                                          101001x0011xxxxx110xxxxxxxxxxxxx
   9046                                                          ld4b.  */
   9047                                                       return 1620;
   9048                                                     }
   9049                                                   else
   9050                                                     {
   9051                                                       /* 33222222222211111111110000000000
   9052                                                          10987654321098765432109876543210
   9053                                                          101001x0111xxxxx110xxxxxxxxxxxxx
   9054                                                          ld4h.  */
   9055                                                       return 1624;
   9056                                                     }
   9057                                                 }
   9058                                             }
   9059                                         }
   9060                                     }
   9061                                 }
   9062                               else
   9063                                 {
   9064                                   if (((word >> 15) & 0x1) == 0)
   9065                                     {
   9066                                       if (((word >> 14) & 0x1) == 0)
   9067                                         {
   9068                                           if (((word >> 12) & 0x1) == 0)
   9069                                             {
   9070                                               if (((word >> 10) & 0x1) == 0)
   9071                                                 {
   9072                                                   if (((word >> 23) & 0x1) == 0)
   9073                                                     {
   9074                                                       /* 33222222222211111111110000000000
   9075                                                          10987654321098765432109876543210
   9076                                                          x11001x00x1xxxxx0000x0xxxxxxxxxx
   9077                                                          fmla.  */
   9078                                                       return 1443;
   9079                                                     }
   9080                                                   else
   9081                                                     {
   9082                                                       if (((word >> 22) & 0x1) == 0)
   9083                                                         {
   9084                                                           /* 33222222222211111111110000000000
   9085                                                              10987654321098765432109876543210
   9086                                                              x11001x0101xxxxx0000x0xxxxxxxxxx
   9087                                                              fmla.  */
   9088                                                           return 1444;
   9089                                                         }
   9090                                                       else
   9091                                                         {
   9092                                                           /* 33222222222211111111110000000000
   9093                                                              10987654321098765432109876543210
   9094                                                              x11001x0111xxxxx0000x0xxxxxxxxxx
   9095                                                              fmla.  */
   9096                                                           return 1445;
   9097                                                         }
   9098                                                     }
   9099                                                 }
   9100                                               else
   9101                                                 {
   9102                                                   if (((word >> 23) & 0x1) == 0)
   9103                                                     {
   9104                                                       /* 33222222222211111111110000000000
   9105                                                          10987654321098765432109876543210
   9106                                                          x11001x00x1xxxxx0000x1xxxxxxxxxx
   9107                                                          fmls.  */
   9108                                                       return 1447;
   9109                                                     }
   9110                                                   else
   9111                                                     {
   9112                                                       if (((word >> 22) & 0x1) == 0)
   9113                                                         {
   9114                                                           /* 33222222222211111111110000000000
   9115                                                              10987654321098765432109876543210
   9116                                                              x11001x0101xxxxx0000x1xxxxxxxxxx
   9117                                                              fmls.  */
   9118                                                           return 1448;
   9119                                                         }
   9120                                                       else
   9121                                                         {
   9122                                                           /* 33222222222211111111110000000000
   9123                                                              10987654321098765432109876543210
   9124                                                              x11001x0111xxxxx0000x1xxxxxxxxxx
   9125                                                              fmls.  */
   9126                                                           return 1449;
   9127                                                         }
   9128                                                     }
   9129                                                 }
   9130                                             }
   9131                                           else
   9132                                             {
   9133                                               if (((word >> 22) & 0x1) == 0)
   9134                                                 {
   9135                                                   /* 33222222222211111111110000000000
   9136                                                      10987654321098765432109876543210
   9137                                                      x11001x0x01xxxxx0001xxxxxxxxxxxx
   9138                                                      fcmla.  */
   9139                                                   return 1391;
   9140                                                 }
   9141                                               else
   9142                                                 {
   9143                                                   /* 33222222222211111111110000000000
   9144                                                      10987654321098765432109876543210
   9145                                                      x11001x0x11xxxxx0001xxxxxxxxxxxx
   9146                                                      fcmla.  */
   9147                                                   return 1392;
   9148                                                 }
   9149                                             }
   9150                                         }
   9151                                       else
   9152                                         {
   9153                                           if (((word >> 22) & 0x1) == 0)
   9154                                             {
   9155                                               if (((word >> 23) & 0x1) == 0)
   9156                                                 {
   9157                                                   /* 33222222222211111111110000000000
   9158                                                      10987654321098765432109876543210
   9159                                                      x11001x0001xxxxx010xxxxxxxxxxxxx
   9160                                                      st1b.  */
   9161                                                   return 1870;
   9162                                                 }
   9163                                               else
   9164                                                 {
   9165                                                   if (((word >> 31) & 0x1) == 0)
   9166                                                     {
   9167                                                       if (((word >> 10) & 0x1) == 0)
   9168                                                         {
   9169                                                           /* 33222222222211111111110000000000
   9170                                                              10987654321098765432109876543210
   9171                                                              011001x0101xxxxx010xx0xxxxxxxxxx
   9172                                                              fmlalb.  */
   9173                                                           return 2082;
   9174                                                         }
   9175                                                       else
   9176                                                         {
   9177                                                           /* 33222222222211111111110000000000
   9178                                                              10987654321098765432109876543210
   9179                                                              011001x0101xxxxx010xx1xxxxxxxxxx
   9180                                                              fmlalt.  */
   9181                                                           return 2084;
   9182                                                         }
   9183                                                     }
   9184                                                   else
   9185                                                     {
   9186                                                       /* 33222222222211111111110000000000
   9187                                                          10987654321098765432109876543210
   9188                                                          111001x0101xxxxx010xxxxxxxxxxxxx
   9189                                                          st1h.  */
   9190                                                       return 1889;
   9191                                                     }
   9192                                                 }
   9193                                             }
   9194                                           else
   9195                                             {
   9196                                               if (((word >> 23) & 0x1) == 0)
   9197                                                 {
   9198                                                   if (((word >> 31) & 0x1) == 0)
   9199                                                     {
   9200                                                       /* 33222222222211111111110000000000
   9201                                                          10987654321098765432109876543210
   9202                                                          011001x0011xxxxx010xxxxxxxxxxxxx
   9203                                                          bfdot.  */
   9204                                                       return 2423;
   9205                                                     }
   9206                                                   else
   9207                                                     {
   9208                                                       /* 33222222222211111111110000000000
   9209                                                          10987654321098765432109876543210
   9210                                                          111001x0011xxxxx010xxxxxxxxxxxxx
   9211                                                          st1b.  */
   9212                                                       return 1873;
   9213                                                     }
   9214                                                 }
   9215                                               else
   9216                                                 {
   9217                                                   if (((word >> 31) & 0x1) == 0)
   9218                                                     {
   9219                                                       if (((word >> 10) & 0x1) == 0)
   9220                                                         {
   9221                                                           /* 33222222222211111111110000000000
   9222                                                              10987654321098765432109876543210
   9223                                                              011001x0111xxxxx010xx0xxxxxxxxxx
   9224                                                              bfmlalb.  */
   9225                                                           return 2430;
   9226                                                         }
   9227                                                       else
   9228                                                         {
   9229                                                           /* 33222222222211111111110000000000
   9230                                                              10987654321098765432109876543210
   9231                                                              011001x0111xxxxx010xx1xxxxxxxxxx
   9232                                                              bfmlalt.  */
   9233                                                           return 2429;
   9234                                                         }
   9235                                                     }
   9236                                                   else
   9237                                                     {
   9238                                                       /* 33222222222211111111110000000000
   9239                                                          10987654321098765432109876543210
   9240                                                          111001x0111xxxxx010xxxxxxxxxxxxx
   9241                                                          st1h.  */
   9242                                                       return 1894;
   9243                                                     }
   9244                                                 }
   9245                                             }
   9246                                         }
   9247                                     }
   9248                                   else
   9249                                     {
   9250                                       if (((word >> 22) & 0x1) == 0)
   9251                                         {
   9252                                           if (((word >> 31) & 0x1) == 0)
   9253                                             {
   9254                                               if (((word >> 10) & 0x1) == 0)
   9255                                                 {
   9256                                                   /* 33222222222211111111110000000000
   9257                                                      10987654321098765432109876543210
   9258                                                      011001x0x01xxxxx1x0xx0xxxxxxxxxx
   9259                                                      fmlalb.  */
   9260                                                   return 2083;
   9261                                                 }
   9262                                               else
   9263                                                 {
   9264                                                   /* 33222222222211111111110000000000
   9265                                                      10987654321098765432109876543210
   9266                                                      011001x0x01xxxxx1x0xx1xxxxxxxxxx
   9267                                                      fmlalt.  */
   9268                                                   return 2085;
   9269                                                 }
   9270                                             }
   9271                                           else
   9272                                             {
   9273                                               /* 33222222222211111111110000000000
   9274                                                  10987654321098765432109876543210
   9275                                                  111001x0x01xxxxx1x0xxxxxxxxxxxxx
   9276                                                  st1h.  */
   9277                                               return 1890;
   9278                                             }
   9279                                         }
   9280                                       else
   9281                                         {
   9282                                           if (((word >> 23) & 0x1) == 0)
   9283                                             {
   9284                                               /* 33222222222211111111110000000000
   9285                                                  10987654321098765432109876543210
   9286                                                  x11001x0011xxxxx1x0xxxxxxxxxxxxx
   9287                                                  bfdot.  */
   9288                                               return 2422;
   9289                                             }
   9290                                           else
   9291                                             {
   9292                                               if (((word >> 31) & 0x1) == 0)
   9293                                                 {
   9294                                                   if (((word >> 10) & 0x1) == 0)
   9295                                                     {
   9296                                                       /* 33222222222211111111110000000000
   9297                                                          10987654321098765432109876543210
   9298                                                          011001x0111xxxxx1x0xx0xxxxxxxxxx
   9299                                                          bfmlalb.  */
   9300                                                       return 2428;
   9301                                                     }
   9302                                                   else
   9303                                                     {
   9304                                                       /* 33222222222211111111110000000000
   9305                                                          10987654321098765432109876543210
   9306                                                          011001x0111xxxxx1x0xx1xxxxxxxxxx
   9307                                                          bfmlalt.  */
   9308                                                       return 2427;
   9309                                                     }
   9310                                                 }
   9311                                               else
   9312                                                 {
   9313                                                   /* 33222222222211111111110000000000
   9314                                                      10987654321098765432109876543210
   9315                                                      111001x0111xxxxx1x0xxxxxxxxxxxxx
   9316                                                      st1h.  */
   9317                                                   return 1895;
   9318                                                 }
   9319                                             }
   9320                                         }
   9321                                     }
   9322                                 }
   9323                             }
   9324                           else
   9325                             {
   9326                               if (((word >> 30) & 0x1) == 0)
   9327                                 {
   9328                                   if (((word >> 31) & 0x1) == 0)
   9329                                     {
   9330                                       if (((word >> 4) & 0x1) == 0)
   9331                                         {
   9332                                           /* 33222222222211111111110000000000
   9333                                              10987654321098765432109876543210
   9334                                              001001x0xx1xxxxxxx1xxxxxxxx0xxxx
   9335                                              cmplo.  */
   9336                                           return 1339;
   9337                                         }
   9338                                       else
   9339                                         {
   9340                                           /* 33222222222211111111110000000000
   9341                                              10987654321098765432109876543210
   9342                                              001001x0xx1xxxxxxx1xxxxxxxx1xxxx
   9343                                              cmpls.  */
   9344                                           return 1341;
   9345                                         }
   9346                                     }
   9347                                   else
   9348                                     {
   9349                                       if (((word >> 14) & 0x1) == 0)
   9350                                         {
   9351                                           if (((word >> 15) & 0x1) == 0)
   9352                                             {
   9353                                               if (((word >> 23) & 0x1) == 0)
   9354                                                 {
   9355                                                   /* 33222222222211111111110000000000
   9356                                                      10987654321098765432109876543210
   9357                                                      101001x00x1xxxxx001xxxxxxxxxxxxx
   9358                                                      ld1rob.  */
   9359                                                   return 2406;
   9360                                                 }
   9361                                               else
   9362                                                 {
   9363                                                   /* 33222222222211111111110000000000
   9364                                                      10987654321098765432109876543210
   9365                                                      101001x01x1xxxxx001xxxxxxxxxxxxx
   9366                                                      ld1roh.  */
   9367                                                   return 2407;
   9368                                                 }
   9369                                             }
   9370                                           else
   9371                                             {
   9372                                               if (((word >> 20) & 0x1) == 0)
   9373                                                 {
   9374                                                   if (((word >> 22) & 0x1) == 0)
   9375                                                     {
   9376                                                       if (((word >> 23) & 0x1) == 0)
   9377                                                         {
   9378                                                           /* 33222222222211111111110000000000
   9379                                                              10987654321098765432109876543210
   9380                                                              101001x00010xxxx101xxxxxxxxxxxxx
   9381                                                              ld1b.  */
   9382                                                           return 1513;
   9383                                                         }
   9384                                                       else
   9385                                                         {
   9386                                                           /* 33222222222211111111110000000000
   9387                                                              10987654321098765432109876543210
   9388                                                              101001x01010xxxx101xxxxxxxxxxxxx
   9389                                                              ld1h.  */
   9390                                                           return 1534;
   9391                                                         }
   9392                                                     }
   9393                                                   else
   9394                                                     {
   9395                                                       if (((word >> 23) & 0x1) == 0)
   9396                                                         {
   9397                                                           /* 33222222222211111111110000000000
   9398                                                              10987654321098765432109876543210
   9399                                                              101001x00110xxxx101xxxxxxxxxxxxx
   9400                                                              ld1b.  */
   9401                                                           return 1515;
   9402                                                         }
   9403                                                       else
   9404                                                         {
   9405                                                           /* 33222222222211111111110000000000
   9406                                                              10987654321098765432109876543210
   9407                                                              101001x01110xxxx101xxxxxxxxxxxxx
   9408                                                              ld1h.  */
   9409                                                           return 1536;
   9410                                                         }
   9411                                                     }
   9412                                                 }
   9413                                               else
   9414                                                 {
   9415                                                   if (((word >> 22) & 0x1) == 0)
   9416                                                     {
   9417                                                       if (((word >> 23) & 0x1) == 0)
   9418                                                         {
   9419                                                           /* 33222222222211111111110000000000
   9420                                                              10987654321098765432109876543210
   9421                                                              101001x00011xxxx101xxxxxxxxxxxxx
   9422                                                              ldnf1b.  */
   9423                                                           return 1705;
   9424                                                         }
   9425                                                       else
   9426                                                         {
   9427                                                           /* 33222222222211111111110000000000
   9428                                                              10987654321098765432109876543210
   9429                                                              101001x01011xxxx101xxxxxxxxxxxxx
   9430                                                              ldnf1h.  */
   9431                                                           return 1709;
   9432                                                         }
   9433                                                     }
   9434                                                   else
   9435                                                     {
   9436                                                       if (((word >> 23) & 0x1) == 0)
   9437                                                         {
   9438                                                           /* 33222222222211111111110000000000
   9439                                                              10987654321098765432109876543210
   9440                                                              101001x00111xxxx101xxxxxxxxxxxxx
   9441                                                              ldnf1b.  */
   9442                                                           return 1707;
   9443                                                         }
   9444                                                       else
   9445                                                         {
   9446                                                           /* 33222222222211111111110000000000
   9447                                                              10987654321098765432109876543210
   9448                                                              101001x01111xxxx101xxxxxxxxxxxxx
   9449                                                              ldnf1h.  */
   9450                                                           return 1711;
   9451                                                         }
   9452                                                     }
   9453                                                 }
   9454                                             }
   9455                                         }
   9456                                       else
   9457                                         {
   9458                                           if (((word >> 15) & 0x1) == 0)
   9459                                             {
   9460                                               if (((word >> 22) & 0x1) == 0)
   9461                                                 {
   9462                                                   if (((word >> 23) & 0x1) == 0)
   9463                                                     {
   9464                                                       /* 33222222222211111111110000000000
   9465                                                          10987654321098765432109876543210
   9466                                                          101001x0001xxxxx011xxxxxxxxxxxxx
   9467                                                          ldff1b.  */
   9468                                                       return 1631;
   9469                                                     }
   9470                                                   else
   9471                                                     {
   9472                                                       /* 33222222222211111111110000000000
   9473                                                          10987654321098765432109876543210
   9474                                                          101001x0101xxxxx011xxxxxxxxxxxxx
   9475                                                          ldff1h.  */
   9476                                                       return 1650;
   9477                                                     }
   9478                                                 }
   9479                                               else
   9480                                                 {
   9481                                                   if (((word >> 23) & 0x1) == 0)
   9482                                                     {
   9483                                                       /* 33222222222211111111110000000000
   9484                                                          10987654321098765432109876543210
   9485                                                          101001x0011xxxxx011xxxxxxxxxxxxx
   9486                                                          ldff1b.  */
   9487                                                       return 1635;
   9488                                                     }
   9489                                                   else
   9490                                                     {
   9491                                                       /* 33222222222211111111110000000000
   9492                                                          10987654321098765432109876543210
   9493                                                          101001x0111xxxxx011xxxxxxxxxxxxx
   9494                                                          ldff1h.  */
   9495                                                       return 1654;
   9496                                                     }
   9497                                                 }
   9498                                             }
   9499                                           else
   9500                                             {
   9501                                               if (((word >> 22) & 0x1) == 0)
   9502                                                 {
   9503                                                   if (((word >> 23) & 0x1) == 0)
   9504                                                     {
   9505                                                       /* 33222222222211111111110000000000
   9506                                                          10987654321098765432109876543210
   9507                                                          101001x0001xxxxx111xxxxxxxxxxxxx
   9508                                                          ld2b.  */
   9509                                                       return 1605;
   9510                                                     }
   9511                                                   else
   9512                                                     {
   9513                                                       /* 33222222222211111111110000000000
   9514                                                          10987654321098765432109876543210
   9515                                                          101001x0101xxxxx111xxxxxxxxxxxxx
   9516                                                          ld2h.  */
   9517                                                       return 1609;
   9518                                                     }
   9519                                                 }
   9520                                               else
   9521                                                 {
   9522                                                   if (((word >> 23) & 0x1) == 0)
   9523                                                     {
   9524                                                       /* 33222222222211111111110000000000
   9525                                                          10987654321098765432109876543210
   9526                                                          101001x0011xxxxx111xxxxxxxxxxxxx
   9527                                                          ld4b.  */
   9528                                                       return 1621;
   9529                                                     }
   9530                                                   else
   9531                                                     {
   9532                                                       /* 33222222222211111111110000000000
   9533                                                          10987654321098765432109876543210
   9534                                                          101001x0111xxxxx111xxxxxxxxxxxxx
   9535                                                          ld4h.  */
   9536                                                       return 1625;
   9537                                                     }
   9538                                                 }
   9539                                             }
   9540                                         }
   9541                                     }
   9542                                 }
   9543                               else
   9544                                 {
   9545                                   if (((word >> 14) & 0x1) == 0)
   9546                                     {
   9547                                       if (((word >> 15) & 0x1) == 0)
   9548                                         {
   9549                                           if (((word >> 23) & 0x1) == 0)
   9550                                             {
   9551                                               /* 33222222222211111111110000000000
   9552                                                  10987654321098765432109876543210
   9553                                                  x11001x00x1xxxxx001xxxxxxxxxxxxx
   9554                                                  fmul.  */
   9555                                               return 1454;
   9556                                             }
   9557                                           else
   9558                                             {
   9559                                               if (((word >> 22) & 0x1) == 0)
   9560                                                 {
   9561                                                   /* 33222222222211111111110000000000
   9562                                                      10987654321098765432109876543210
   9563                                                      x11001x0101xxxxx001xxxxxxxxxxxxx
   9564                                                      fmul.  */
   9565                                                   return 1455;
   9566                                                 }
   9567                                               else
   9568                                                 {
   9569                                                   /* 33222222222211111111110000000000
   9570                                                      10987654321098765432109876543210
   9571                                                      x11001x0111xxxxx001xxxxxxxxxxxxx
   9572                                                      fmul.  */
   9573                                                   return 1456;
   9574                                                 }
   9575                                             }
   9576                                         }
   9577                                       else
   9578                                         {
   9579                                           if (((word >> 22) & 0x1) == 0)
   9580                                             {
   9581                                               if (((word >> 31) & 0x1) == 0)
   9582                                                 {
   9583                                                   if (((word >> 10) & 0x1) == 0)
   9584                                                     {
   9585                                                       /* 33222222222211111111110000000000
   9586                                                          10987654321098765432109876543210
   9587                                                          011001x0x01xxxxx101xx0xxxxxxxxxx
   9588                                                          fmlslb.  */
   9589                                                       return 2087;
   9590                                                     }
   9591                                                   else
   9592                                                     {
   9593                                                       /* 33222222222211111111110000000000
   9594                                                          10987654321098765432109876543210
   9595                                                          011001x0x01xxxxx101xx1xxxxxxxxxx
   9596                                                          fmlslt.  */
   9597                                                       return 2089;
   9598                                                     }
   9599                                                 }
   9600                                               else
   9601                                                 {
   9602                                                   /* 33222222222211111111110000000000
   9603                                                      10987654321098765432109876543210
   9604                                                      111001x0x01xxxxx101xxxxxxxxxxxxx
   9605                                                      st1h.  */
   9606                                                   return 1891;
   9607                                                 }
   9608                                             }
   9609                                           else
   9610                                             {
   9611                                               if (((word >> 23) & 0x1) == 0)
   9612                                                 {
   9613                                                   /* 33222222222211111111110000000000
   9614                                                      10987654321098765432109876543210
   9615                                                      x11001x0011xxxxx101xxxxxxxxxxxxx
   9616                                                      st1b.  */
   9617                                                   return 1878;
   9618                                                 }
   9619                                               else
   9620                                                 {
   9621                                                   /* 33222222222211111111110000000000
   9622                                                      10987654321098765432109876543210
   9623                                                      x11001x0111xxxxx101xxxxxxxxxxxxx
   9624                                                      st1h.  */
   9625                                                   return 1899;
   9626                                                 }
   9627                                             }
   9628                                         }
   9629                                     }
   9630                                   else
   9631                                     {
   9632                                       if (((word >> 15) & 0x1) == 0)
   9633                                         {
   9634                                           if (((word >> 22) & 0x1) == 0)
   9635                                             {
   9636                                               if (((word >> 23) & 0x1) == 0)
   9637                                                 {
   9638                                                   /* 33222222222211111111110000000000
   9639                                                      10987654321098765432109876543210
   9640                                                      x11001x0001xxxxx011xxxxxxxxxxxxx
   9641                                                      st2b.  */
   9642                                                   return 1913;
   9643                                                 }
   9644                                               else
   9645                                                 {
   9646                                                   if (((word >> 31) & 0x1) == 0)
   9647                                                     {
   9648                                                       if (((word >> 10) & 0x1) == 0)
   9649                                                         {
   9650                                                           /* 33222222222211111111110000000000
   9651                                                              10987654321098765432109876543210
   9652                                                              011001x0101xxxxx011xx0xxxxxxxxxx
   9653                                                              fmlslb.  */
   9654                                                           return 2086;
   9655                                                         }
   9656                                                       else
   9657                                                         {
   9658                                                           /* 33222222222211111111110000000000
   9659                                                              10987654321098765432109876543210
   9660                                                              011001x0101xxxxx011xx1xxxxxxxxxx
   9661                                                              fmlslt.  */
   9662                                                           return 2088;
   9663                                                         }
   9664                                                     }
   9665                                                   else
   9666                                                     {
   9667                                                       /* 33222222222211111111110000000000
   9668                                                          10987654321098765432109876543210
   9669                                                          111001x0101xxxxx011xxxxxxxxxxxxx
   9670                                                          st2h.  */
   9671                                                       return 1917;
   9672                                                     }
   9673                                                 }
   9674                                             }
   9675                                           else
   9676                                             {
   9677                                               if (((word >> 23) & 0x1) == 0)
   9678                                                 {
   9679                                                   /* 33222222222211111111110000000000
   9680                                                      10987654321098765432109876543210
   9681                                                      x11001x0011xxxxx011xxxxxxxxxxxxx
   9682                                                      st4b.  */
   9683                                                   return 1929;
   9684                                                 }
   9685                                               else
   9686                                                 {
   9687                                                   /* 33222222222211111111110000000000
   9688                                                      10987654321098765432109876543210
   9689                                                      x11001x0111xxxxx011xxxxxxxxxxxxx
   9690                                                      st4h.  */
   9691                                                   return 1933;
   9692                                                 }
   9693                                             }
   9694                                         }
   9695                                       else
   9696                                         {
   9697                                           if (((word >> 22) & 0x1) == 0)
   9698                                             {
   9699                                               if (((word >> 23) & 0x1) == 0)
   9700                                                 {
   9701                                                   if (((word >> 20) & 0x1) == 0)
   9702                                                     {
   9703                                                       /* 33222222222211111111110000000000
   9704                                                          10987654321098765432109876543210
   9705                                                          x11001x00010xxxx111xxxxxxxxxxxxx
   9706                                                          st1b.  */
   9707                                                       return 1875;
   9708                                                     }
   9709                                                   else
   9710                                                     {
   9711                                                       /* 33222222222211111111110000000000
   9712                                                          10987654321098765432109876543210
   9713                                                          x11001x00011xxxx111xxxxxxxxxxxxx
   9714                                                          st2b.  */
   9715                                                       return 1914;
   9716                                                     }
   9717                                                 }
   9718                                               else
   9719                                                 {
   9720                                                   if (((word >> 31) & 0x1) == 0)
   9721                                                     {
   9722                                                       /* 33222222222211111111110000000000
   9723                                                          10987654321098765432109876543210
   9724                                                          011001x0101xxxxx111xxxxxxxxxxxxx
   9725                                                          fmmla.  */
   9726                                                       return 2400;
   9727                                                     }
   9728                                                   else
   9729                                                     {
   9730                                                       if (((word >> 20) & 0x1) == 0)
   9731                                                         {
   9732                                                           /* 33222222222211111111110000000000
   9733                                                              10987654321098765432109876543210
   9734                                                              111001x01010xxxx111xxxxxxxxxxxxx
   9735                                                              st1h.  */
   9736                                                           return 1896;
   9737                                                         }
   9738                                                       else
   9739                                                         {
   9740                                                           /* 33222222222211111111110000000000
   9741                                                              10987654321098765432109876543210
   9742                                                              111001x01011xxxx111xxxxxxxxxxxxx
   9743                                                              st2h.  */
   9744                                                           return 1918;
   9745                                                         }
   9746                                                     }
   9747                                                 }
   9748                                             }
   9749                                           else
   9750                                             {
   9751                                               if (((word >> 23) & 0x1) == 0)
   9752                                                 {
   9753                                                   if (((word >> 31) & 0x1) == 0)
   9754                                                     {
   9755                                                       /* 33222222222211111111110000000000
   9756                                                          10987654321098765432109876543210
   9757                                                          011001x0011xxxxx111xxxxxxxxxxxxx
   9758                                                          bfmmla.  */
   9759                                                       return 2424;
   9760                                                     }
   9761                                                   else
   9762                                                     {
   9763                                                       if (((word >> 20) & 0x1) == 0)
   9764                                                         {
   9765                                                           /* 33222222222211111111110000000000
   9766                                                              10987654321098765432109876543210
   9767                                                              111001x00110xxxx111xxxxxxxxxxxxx
   9768                                                              st1b.  */
   9769                                                           return 1879;
   9770                                                         }
   9771                                                       else
   9772                                                         {
   9773                                                           /* 33222222222211111111110000000000
   9774                                                              10987654321098765432109876543210
   9775                                                              111001x00111xxxx111xxxxxxxxxxxxx
   9776                                                              st4b.  */
   9777                                                           return 1930;
   9778                                                         }
   9779                                                     }
   9780                                                 }
   9781                                               else
   9782                                                 {
   9783                                                   if (((word >> 31) & 0x1) == 0)
   9784                                                     {
   9785                                                       /* 33222222222211111111110000000000
   9786                                                          10987654321098765432109876543210
   9787                                                          011001x0111xxxxx111xxxxxxxxxxxxx
   9788                                                          fmmla.  */
   9789                                                       return 2401;
   9790                                                     }
   9791                                                   else
   9792                                                     {
   9793                                                       if (((word >> 20) & 0x1) == 0)
   9794                                                         {
   9795                                                           /* 33222222222211111111110000000000
   9796                                                              10987654321098765432109876543210
   9797                                                              111001x01110xxxx111xxxxxxxxxxxxx
   9798                                                              st1h.  */
   9799                                                           return 1900;
   9800                                                         }
   9801                                                       else
   9802                                                         {
   9803                                                           /* 33222222222211111111110000000000
   9804                                                              10987654321098765432109876543210
   9805                                                              111001x01111xxxx111xxxxxxxxxxxxx
   9806                                                              st4h.  */
   9807                                                           return 1934;
   9808                                                         }
   9809                                                     }
   9810                                                 }
   9811                                             }
   9812                                         }
   9813                                     }
   9814                                 }
   9815                             }
   9816                         }
   9817                     }
   9818                 }
   9819               else
   9820                 {
   9821                   if (((word >> 29) & 0x1) == 0)
   9822                     {
   9823                       if (((word >> 30) & 0x1) == 0)
   9824                         {
   9825                           if (((word >> 31) & 0x1) == 0)
   9826                             {
   9827                               if (((word >> 21) & 0x1) == 0)
   9828                                 {
   9829                                   if (((word >> 20) & 0x1) == 0)
   9830                                     {
   9831                                       if (((word >> 22) & 0x1) == 0)
   9832                                         {
   9833                                           if (((word >> 23) & 0x1) == 0)
   9834                                             {
   9835                                               /* 33222222222211111111110000000000
   9836                                                  10987654321098765432109876543210
   9837                                                  000001x10000xxxxxxxxxxxxxxxxxxxx
   9838                                                  orr.  */
   9839                                               return 1759;
   9840                                             }
   9841                                           else
   9842                                             {
   9843                                               /* 33222222222211111111110000000000
   9844                                                  10987654321098765432109876543210
   9845                                                  000001x11000xxxxxxxxxxxxxxxxxxxx
   9846                                                  and.  */
   9847                                               return 1287;
   9848                                             }
   9849                                         }
   9850                                       else
   9851                                         {
   9852                                           if (((word >> 23) & 0x1) == 0)
   9853                                             {
   9854                                               /* 33222222222211111111110000000000
   9855                                                  10987654321098765432109876543210
   9856                                                  000001x10100xxxxxxxxxxxxxxxxxxxx
   9857                                                  eor.  */
   9858                                               return 1374;
   9859                                             }
   9860                                           else
   9861                                             {
   9862                                               /* 33222222222211111111110000000000
   9863                                                  10987654321098765432109876543210
   9864                                                  000001x11100xxxxxxxxxxxxxxxxxxxx
   9865                                                  dupm.  */
   9866                                               return 1372;
   9867                                             }
   9868                                         }
   9869                                     }
   9870                                   else
   9871                                     {
   9872                                       if (((word >> 15) & 0x1) == 0)
   9873                                         {
   9874                                           /* 33222222222211111111110000000000
   9875                                              10987654321098765432109876543210
   9876                                              000001x1xx01xxxx0xxxxxxxxxxxxxxx
   9877                                              cpy.  */
   9878                                           return 1357;
   9879                                         }
   9880                                       else
   9881                                         {
   9882                                           /* 33222222222211111111110000000000
   9883                                              10987654321098765432109876543210
   9884                                              000001x1xx01xxxx1xxxxxxxxxxxxxxx
   9885                                              fcpy.  */
   9886                                           return 1404;
   9887                                         }
   9888                                     }
   9889                                 }
   9890                               else
   9891                                 {
   9892                                   if (((word >> 14) & 0x1) == 0)
   9893                                     {
   9894                                       if (((word >> 13) & 0x1) == 0)
   9895                                         {
   9896                                           if (((word >> 15) & 0x1) == 0)
   9897                                             {
   9898                                               if (((word >> 22) & 0x1) == 0)
   9899                                                 {
   9900                                                   if (((word >> 23) & 0x1) == 0)
   9901                                                     {
   9902                                                       /* 33222222222211111111110000000000
   9903                                                          10987654321098765432109876543210
   9904                                                          000001x1001xxxxx000xxxxxxxxxxxxx
   9905                                                          ext.  */
   9906                                                       return 1379;
   9907                                                     }
   9908                                                   else
   9909                                                     {
   9910                                                       if (((word >> 10) & 0x1) == 0)
   9911                                                         {
   9912                                                           if (((word >> 11) & 0x1) == 0)
   9913                                                             {
   9914                                                               /* 33222222222211111111110000000000
   9915                                                                  10987654321098765432109876543210
   9916                                                                  000001x1101xxxxx000x00xxxxxxxxxx
   9917                                                                  zip1.  */
   9918                                                               return 2410;
   9919                                                             }
   9920                                                           else
   9921                                                             {
   9922                                                               if (((word >> 12) & 0x1) == 0)
   9923                                                                 {
   9924                                                                   /* 33222222222211111111110000000000
   9925                                                                      10987654321098765432109876543210
   9926                                                                      000001x1101xxxxx000010xxxxxxxxxx
   9927                                                                      uzp1.  */
   9928                                                                   return 2412;
   9929                                                                 }
   9930                                                               else
   9931                                                                 {
   9932                                                                   /* 33222222222211111111110000000000
   9933                                                                      10987654321098765432109876543210
   9934                                                                      000001x1101xxxxx000110xxxxxxxxxx
   9935                                                                      trn1.  */
   9936                                                                   return 2414;
   9937                                                                 }
   9938                                                             }
   9939                                                         }
   9940                                                       else
   9941                                                         {
   9942                                                           if (((word >> 11) & 0x1) == 0)
   9943                                                             {
   9944                                                               /* 33222222222211111111110000000000
   9945                                                                  10987654321098765432109876543210
   9946                                                                  000001x1101xxxxx000x01xxxxxxxxxx
   9947                                                                  zip2.  */
   9948                                                               return 2411;
   9949                                                             }
   9950                                                           else
   9951                                                             {
   9952                                                               if (((word >> 12) & 0x1) == 0)
   9953                                                                 {
   9954                                                                   /* 33222222222211111111110000000000
   9955                                                                      10987654321098765432109876543210
   9956                                                                      000001x1101xxxxx000011xxxxxxxxxx
   9957                                                                      uzp2.  */
   9958                                                                   return 2413;
   9959                                                                 }
   9960                                                               else
   9961                                                                 {
   9962                                                                   /* 33222222222211111111110000000000
   9963                                                                      10987654321098765432109876543210
   9964                                                                      000001x1101xxxxx000111xxxxxxxxxx
   9965                                                                      trn2.  */
   9966                                                                   return 2415;
   9967                                                                 }
   9968                                                             }
   9969                                                         }
   9970                                                     }
   9971                                                 }
   9972                                               else
   9973                                                 {
   9974                                                   /* 33222222222211111111110000000000
   9975                                                      10987654321098765432109876543210
   9976                                                      000001x1x11xxxxx000xxxxxxxxxxxxx
   9977                                                      ext.  */
   9978                                                   return 2069;
   9979                                                 }
   9980                                             }
   9981                                           else
   9982                                             {
   9983                                               if (((word >> 16) & 0x1) == 0)
   9984                                                 {
   9985                                                   if (((word >> 17) & 0x1) == 0)
   9986                                                     {
   9987                                                       if (((word >> 18) & 0x1) == 0)
   9988                                                         {
   9989                                                           if (((word >> 19) & 0x1) == 0)
   9990                                                             {
   9991                                                               /* 33222222222211111111110000000000
   9992                                                                  10987654321098765432109876543210
   9993                                                                  000001x1xx1x0000100xxxxxxxxxxxxx
   9994                                                                  cpy.  */
   9995                                                               return 1355;
   9996                                                             }
   9997                                                           else
   9998                                                             {
   9999                                                               /* 33222222222211111111110000000000
   10000                                                                  10987654321098765432109876543210
   10001                                                                  000001x1xx1x1000100xxxxxxxxxxxxx
   10002                                                                  clasta.  */
   10003                                                               return 1313;
   10004                                                             }
   10005                                                         }
   10006                                                       else
   10007                                                         {
   10008                                                           if (((word >> 19) & 0x1) == 0)
   10009                                                             {
   10010                                                               /* 33222222222211111111110000000000
   10011                                                                  10987654321098765432109876543210
   10012                                                                  000001x1xx1x0100100xxxxxxxxxxxxx
   10013                                                                  revb.  */
   10014                                                               return 1807;
   10015                                                             }
   10016                                                           else
   10017                                                             {
   10018                                                               /* 33222222222211111111110000000000
   10019                                                                  10987654321098765432109876543210
   10020                                                                  000001x1xx1x1100100xxxxxxxxxxxxx
   10021                                                                  splice.  */
   10022                                                               return 1834;
   10023                                                             }
   10024                                                         }
   10025                                                     }
   10026                                                   else
   10027                                                     {
   10028                                                       if (((word >> 18) & 0x1) == 0)
   10029                                                         {
   10030                                                           if (((word >> 19) & 0x1) == 0)
   10031                                                             {
   10032                                                               /* 33222222222211111111110000000000
   10033                                                                  10987654321098765432109876543210
   10034                                                                  000001x1xx1x0010100xxxxxxxxxxxxx
   10035                                                                  lasta.  */
   10036                                                               return 1501;
   10037                                                             }
   10038                                                           else
   10039                                                             {
   10040                                                               /* 33222222222211111111110000000000
   10041                                                                  10987654321098765432109876543210
   10042                                                                  000001x1xx1x1010100xxxxxxxxxxxxx
   10043                                                                  clasta.  */
   10044                                                               return 1314;
   10045                                                             }
   10046                                                         }
   10047                                                       else
   10048                                                         {
   10049                                                           /* 33222222222211111111110000000000
   10050                                                              10987654321098765432109876543210
   10051                                                              000001x1xx1xx110100xxxxxxxxxxxxx
   10052                                                              revw.  */
   10053                                                           return 1809;
   10054                                                         }
   10055                                                     }
   10056                                                 }
   10057                                               else
   10058                                                 {
   10059                                                   if (((word >> 17) & 0x1) == 0)
   10060                                                     {
   10061                                                       if (((word >> 18) & 0x1) == 0)
   10062                                                         {
   10063                                                           if (((word >> 19) & 0x1) == 0)
   10064                                                             {
   10065                                                               /* 33222222222211111111110000000000
   10066                                                                  10987654321098765432109876543210
   10067                                                                  000001x1xx1x0001100xxxxxxxxxxxxx
   10068                                                                  compact.  */
   10069                                                               return 1354;
   10070                                                             }
   10071                                                           else
   10072                                                             {
   10073                                                               /* 33222222222211111111110000000000
   10074                                                                  10987654321098765432109876543210
   10075                                                                  000001x1xx1x1001100xxxxxxxxxxxxx
   10076                                                                  clastb.  */
   10077                                                               return 1316;
   10078                                                             }
   10079                                                         }
   10080                                                       else
   10081                                                         {
   10082                                                           if (((word >> 19) & 0x1) == 0)
   10083                                                             {
   10084                                                               /* 33222222222211111111110000000000
   10085                                                                  10987654321098765432109876543210
   10086                                                                  000001x1xx1x0101100xxxxxxxxxxxxx
   10087                                                                  revh.  */
   10088                                                               return 1808;
   10089                                                             }
   10090                                                           else
   10091                                                             {
   10092                                                               /* 33222222222211111111110000000000
   10093                                                                  10987654321098765432109876543210
   10094                                                                  000001x1xx1x1101100xxxxxxxxxxxxx
   10095                                                                  splice.  */
   10096                                                               return 2164;
   10097                                                             }
   10098                                                         }
   10099                                                     }
   10100                                                   else
   10101                                                     {
   10102                                                       if (((word >> 18) & 0x1) == 0)
   10103                                                         {
   10104                                                           if (((word >> 19) & 0x1) == 0)
   10105                                                             {
   10106                                                               /* 33222222222211111111110000000000
   10107                                                                  10987654321098765432109876543210
   10108                                                                  000001x1xx1x0011100xxxxxxxxxxxxx
   10109                                                                  lastb.  */
   10110                                                               return 1503;
   10111                                                             }
   10112                                                           else
   10113                                                             {
   10114                                                               /* 33222222222211111111110000000000
   10115                                                                  10987654321098765432109876543210
   10116                                                                  000001x1xx1x1011100xxxxxxxxxxxxx
   10117                                                                  clastb.  */
   10118                                                               return 1317;
   10119                                                             }
   10120                                                         }
   10121                                                       else
   10122                                                         {
   10123                                                           /* 33222222222211111111110000000000
   10124                                                              10987654321098765432109876543210
   10125                                                              000001x1xx1xx111100xxxxxxxxxxxxx
   10126                                                              rbit.  */
   10127                                                           return 1800;
   10128                                                         }
   10129                                                     }
   10130                                                 }
   10131                                             }
   10132                                         }
   10133                                       else
   10134                                         {
   10135                                           if (((word >> 15) & 0x1) == 0)
   10136                                             {
   10137                                               if (((word >> 10) & 0x1) == 0)
   10138                                                 {
   10139                                                   if (((word >> 11) & 0x1) == 0)
   10140                                                     {
   10141                                                       if (((word >> 12) & 0x1) == 0)
   10142                                                         {
   10143                                                           /* 33222222222211111111110000000000
   10144                                                              10987654321098765432109876543210
   10145                                                              000001x1xx1xxxxx001000xxxxxxxxxx
   10146                                                              dup.  */
   10147                                                           return 1370;
   10148                                                         }
   10149                                                       else
   10150                                                         {
   10151                                                           /* 33222222222211111111110000000000
   10152                                                              10987654321098765432109876543210
   10153                                                              000001x1xx1xxxxx001100xxxxxxxxxx
   10154                                                              tbl.  */
   10155                                                           return 1957;
   10156                                                         }
   10157                                                     }
   10158                                                   else
   10159                                                     {
   10160                                                       if (((word >> 12) & 0x1) == 0)
   10161                                                         {
   10162                                                           /* 33222222222211111111110000000000
   10163                                                              10987654321098765432109876543210
   10164                                                              000001x1xx1xxxxx001010xxxxxxxxxx
   10165                                                              tbl.  */
   10166                                                           return 2253;
   10167                                                         }
   10168                                                       else
   10169                                                         {
   10170                                                           if (((word >> 16) & 0x1) == 0)
   10171                                                             {
   10172                                                               if (((word >> 17) & 0x1) == 0)
   10173                                                                 {
   10174                                                                   if (((word >> 18) & 0x1) == 0)
   10175                                                                     {
   10176                                                                       if (((word >> 19) & 0x1) == 0)
   10177                                                                         {
   10178                                                                           if (((word >> 20) & 0x1) == 0)
   10179                                                                             {
   10180                                                                               /* 33222222222211111111110000000000
   10181                                                                                  10987654321098765432109876543210
   10182                                                                                  000001x1xx100000001110xxxxxxxxxx
   10183                                                                                  dup.  */
   10184                                                                               return 1369;
   10185                                                                             }
   10186                                                                           else
   10187                                                                             {
   10188                                                                               /* 33222222222211111111110000000000
   10189                                                                                  10987654321098765432109876543210
   10190                                                                                  000001x1xx110000001110xxxxxxxxxx
   10191                                                                                  sunpklo.  */
   10192                                                                               return 1953;
   10193                                                                             }
   10194                                                                         }
   10195                                                                       else
   10196                                                                         {
   10197                                                                           /* 33222222222211111111110000000000
   10198                                                                              10987654321098765432109876543210
   10199                                                                              000001x1xx1x1000001110xxxxxxxxxx
   10200                                                                              rev.  */
   10201                                                                           return 1806;
   10202                                                                         }
   10203                                                                     }
   10204                                                                   else
   10205                                                                     {
   10206                                                                       if (((word >> 20) & 0x1) == 0)
   10207                                                                         {
   10208                                                                           /* 33222222222211111111110000000000
   10209                                                                              10987654321098765432109876543210
   10210                                                                              000001x1xx10x100001110xxxxxxxxxx
   10211                                                                              insr.  */
   10212                                                                           return 1498;
   10213                                                                         }
   10214                                                                       else
   10215                                                                         {
   10216                                                                           /* 33222222222211111111110000000000
   10217                                                                              10987654321098765432109876543210
   10218                                                                              000001x1xx11x100001110xxxxxxxxxx
   10219                                                                              insr.  */
   10220                                                                           return 1499;
   10221                                                                         }
   10222                                                                     }
   10223                                                                 }
   10224                                                               else
   10225                                                                 {
   10226                                                                   /* 33222222222211111111110000000000
   10227                                                                      10987654321098765432109876543210
   10228                                                                      000001x1xx1xxx10001110xxxxxxxxxx
   10229                                                                      uunpklo.  */
   10230                                                                   return 2016;
   10231                                                                 }
   10232                                                             }
   10233                                                           else
   10234                                                             {
   10235                                                               if (((word >> 17) & 0x1) == 0)
   10236                                                                 {
   10237                                                                   /* 33222222222211111111110000000000
   10238                                                                      10987654321098765432109876543210
   10239                                                                      000001x1xx1xxx01001110xxxxxxxxxx
   10240                                                                      sunpkhi.  */
   10241                                                                   return 1952;
   10242                                                                 }
   10243                                                               else
   10244                                                                 {
   10245                                                                   /* 33222222222211111111110000000000
   10246                                                                      10987654321098765432109876543210
   10247                                                                      000001x1xx1xxx11001110xxxxxxxxxx
   10248                                                                      uunpkhi.  */
   10249                                                                   return 2015;
   10250                                                                 }
   10251                                                             }
   10252                                                         }
   10253                                                     }
   10254                                                 }
   10255                                               else
   10256                                                 {
   10257                                                   /* 33222222222211111111110000000000
   10258                                                      10987654321098765432109876543210
   10259                                                      000001x1xx1xxxxx001xx1xxxxxxxxxx
   10260                                                      tbx.  */
   10261                                                   return 2254;
   10262                                                 }
   10263                                             }
   10264                                           else
   10265                                             {
   10266                                               if (((word >> 16) & 0x1) == 0)
   10267                                                 {
   10268                                                   if (((word >> 19) & 0x1) == 0)
   10269                                                     {
   10270                                                       if (((word >> 20) & 0x1) == 0)
   10271                                                         {
   10272                                                           /* 33222222222211111111110000000000
   10273                                                              10987654321098765432109876543210
   10274                                                              000001x1xx100xx0101xxxxxxxxxxxxx
   10275                                                              lasta.  */
   10276                                                           return 1500;
   10277                                                         }
   10278                                                       else
   10279                                                         {
   10280                                                           /* 33222222222211111111110000000000
   10281                                                              10987654321098765432109876543210
   10282                                                              000001x1xx110xx0101xxxxxxxxxxxxx
   10283                                                              clasta.  */
   10284                                                           return 1315;
   10285                                                         }
   10286                                                     }
   10287                                                   else
   10288                                                     {
   10289                                                       /* 33222222222211111111110000000000
   10290                                                          10987654321098765432109876543210
   10291                                                          000001x1xx1x1xx0101xxxxxxxxxxxxx
   10292                                                          cpy.  */
   10293                                                       return 1356;
   10294                                                     }
   10295                                                 }
   10296                                               else
   10297                                                 {
   10298                                                   if (((word >> 20) & 0x1) == 0)
   10299                                                     {
   10300                                                       /* 33222222222211111111110000000000
   10301                                                          10987654321098765432109876543210
   10302                                                          000001x1xx10xxx1101xxxxxxxxxxxxx
   10303                                                          lastb.  */
   10304                                                       return 1502;
   10305                                                     }
   10306                                                   else
   10307                                                     {
   10308                                                       /* 33222222222211111111110000000000
   10309                                                          10987654321098765432109876543210
   10310                                                          000001x1xx11xxx1101xxxxxxxxxxxxx
   10311                                                          clastb.  */
   10312                                                       return 1318;
   10313                                                     }
   10314                                                 }
   10315                                             }
   10316                                         }
   10317                                     }
   10318                                   else
   10319                                     {
   10320                                       if (((word >> 15) & 0x1) == 0)
   10321                                         {
   10322                                           if (((word >> 10) & 0x1) == 0)
   10323                                             {
   10324                                               if (((word >> 11) & 0x1) == 0)
   10325                                                 {
   10326                                                   if (((word >> 12) & 0x1) == 0)
   10327                                                     {
   10328                                                       if (((word >> 13) & 0x1) == 0)
   10329                                                         {
   10330                                                           if (((word >> 20) & 0x1) == 0)
   10331                                                             {
   10332                                                               /* 33222222222211111111110000000000
   10333                                                                  10987654321098765432109876543210
   10334                                                                  000001x1xx10xxxx010000xxxxxxxxxx
   10335                                                                  zip1.  */
   10336                                                               return 2033;
   10337                                                             }
   10338                                                           else
   10339                                                             {
   10340                                                               if (((word >> 16) & 0x1) == 0)
   10341                                                                 {
   10342                                                                   if (((word >> 18) & 0x1) == 0)
   10343                                                                     {
   10344                                                                       /* 33222222222211111111110000000000
   10345                                                                          10987654321098765432109876543210
   10346                                                                          000001x1xx11x0x0010000xxxxxxxxxx
   10347                                                                          punpklo.  */
   10348                                                                       return 1799;
   10349                                                                     }
   10350                                                                   else
   10351                                                                     {
   10352                                                                       /* 33222222222211111111110000000000
   10353                                                                          10987654321098765432109876543210
   10354                                                                          000001x1xx11x1x0010000xxxxxxxxxx
   10355                                                                          rev.  */
   10356                                                                       return 1805;
   10357                                                                     }
   10358                                                                 }
   10359                                                               else
   10360                                                                 {
   10361                                                                   /* 33222222222211111111110000000000
   10362                                                                      10987654321098765432109876543210
   10363                                                                      000001x1xx11xxx1010000xxxxxxxxxx
   10364                                                                      punpkhi.  */
   10365                                                                   return 1798;
   10366                                                                 }
   10367                                                             }
   10368                                                         }
   10369                                                       else
   10370                                                         {
   10371                                                           /* 33222222222211111111110000000000
   10372                                                              10987654321098765432109876543210
   10373                                                              000001x1xx1xxxxx011000xxxxxxxxxx
   10374                                                              zip1.  */
   10375                                                           return 2034;
   10376                                                         }
   10377                                                     }
   10378                                                   else
   10379                                                     {
   10380                                                       if (((word >> 13) & 0x1) == 0)
   10381                                                         {
   10382                                                           /* 33222222222211111111110000000000
   10383                                                              10987654321098765432109876543210
   10384                                                              000001x1xx1xxxxx010100xxxxxxxxxx
   10385                                                              trn1.  */
   10386                                                           return 1958;
   10387                                                         }
   10388                                                       else
   10389                                                         {
   10390                                                           /* 33222222222211111111110000000000
   10391                                                              10987654321098765432109876543210
   10392                                                              000001x1xx1xxxxx011100xxxxxxxxxx
   10393                                                              trn1.  */
   10394                                                           return 1959;
   10395                                                         }
   10396                                                     }
   10397                                                 }
   10398                                               else
   10399                                                 {
   10400                                                   if (((word >> 13) & 0x1) == 0)
   10401                                                     {
   10402                                                       /* 33222222222211111111110000000000
   10403                                                          10987654321098765432109876543210
   10404                                                          000001x1xx1xxxxx010x10xxxxxxxxxx
   10405                                                          uzp1.  */
   10406                                                       return 2020;
   10407                                                     }
   10408                                                   else
   10409                                                     {
   10410                                                       /* 33222222222211111111110000000000
   10411                                                          10987654321098765432109876543210
   10412                                                          000001x1xx1xxxxx011x10xxxxxxxxxx
   10413                                                          uzp1.  */
   10414                                                       return 2021;
   10415                                                     }
   10416                                                 }
   10417                                             }
   10418                                           else
   10419                                             {
   10420                                               if (((word >> 11) & 0x1) == 0)
   10421                                                 {
   10422                                                   if (((word >> 12) & 0x1) == 0)
   10423                                                     {
   10424                                                       if (((word >> 13) & 0x1) == 0)
   10425                                                         {
   10426                                                           /* 33222222222211111111110000000000
   10427                                                              10987654321098765432109876543210
   10428                                                              000001x1xx1xxxxx010001xxxxxxxxxx
   10429                                                              zip2.  */
   10430                                                           return 2035;
   10431                                                         }
   10432                                                       else
   10433                                                         {
   10434                                                           /* 33222222222211111111110000000000
   10435                                                              10987654321098765432109876543210
   10436                                                              000001x1xx1xxxxx011001xxxxxxxxxx
   10437                                                              zip2.  */
   10438                                                           return 2036;
   10439                                                         }
   10440                                                     }
   10441                                                   else
   10442                                                     {
   10443                                                       if (((word >> 13) & 0x1) == 0)
   10444                                                         {
   10445                                                           /* 33222222222211111111110000000000
   10446                                                              10987654321098765432109876543210
   10447                                                              000001x1xx1xxxxx010101xxxxxxxxxx
   10448                                                              trn2.  */
   10449                                                           return 1960;
   10450                                                         }
   10451                                                       else
   10452                                                         {
   10453                                                           /* 33222222222211111111110000000000
   10454                                                              10987654321098765432109876543210
   10455                                                              000001x1xx1xxxxx011101xxxxxxxxxx
   10456                                                              trn2.  */
   10457                                                           return 1961;
   10458                                                         }
   10459                                                     }
   10460                                                 }
   10461                                               else
   10462                                                 {
   10463                                                   if (((word >> 13) & 0x1) == 0)
   10464                                                     {
   10465                                                       /* 33222222222211111111110000000000
   10466                                                          10987654321098765432109876543210
   10467                                                          000001x1xx1xxxxx010x11xxxxxxxxxx
   10468                                                          uzp2.  */
   10469                                                       return 2022;
   10470                                                     }
   10471                                                   else
   10472                                                     {
   10473                                                       /* 33222222222211111111110000000000
   10474                                                          10987654321098765432109876543210
   10475                                                          000001x1xx1xxxxx011x11xxxxxxxxxx
   10476                                                          uzp2.  */
   10477                                                       return 2023;
   10478                                                     }
   10479                                                 }
   10480                                             }
   10481                                         }
   10482                                       else
   10483                                         {
   10484                                           /* 33222222222211111111110000000000
   10485                                              10987654321098765432109876543210
   10486                                              000001x1xx1xxxxx11xxxxxxxxxxxxxx
   10487                                              sel.  */
   10488                                           return 1824;
   10489                                         }
   10490                                     }
   10491                                 }
   10492                             }
   10493                           else
   10494                             {
   10495                               if (((word >> 13) & 0x1) == 0)
   10496                                 {
   10497                                   if (((word >> 14) & 0x1) == 0)
   10498                                     {
   10499                                       if (((word >> 15) & 0x1) == 0)
   10500                                         {
   10501                                           if (((word >> 22) & 0x1) == 0)
   10502                                             {
   10503                                               /* 33222222222211111111110000000000
   10504                                                  10987654321098765432109876543210
   10505                                                  100001x1x0xxxxxx000xxxxxxxxxxxxx
   10506                                                  ldr.  */
   10507                                               return 1728;
   10508                                             }
   10509                                           else
   10510                                             {
   10511                                               /* 33222222222211111111110000000000
   10512                                                  10987654321098765432109876543210
   10513                                                  100001x1x1xxxxxx000xxxxxxxxxxxxx
   10514                                                  prfb.  */
   10515                                               return 1772;
   10516                                             }
   10517                                         }
   10518                                       else
   10519                                         {
   10520                                           if (((word >> 23) & 0x1) == 0)
   10521                                             {
   10522                                               /* 33222222222211111111110000000000
   10523                                                  10987654321098765432109876543210
   10524                                                  100001x10xxxxxxx100xxxxxxxxxxxxx
   10525                                                  ld1rsh.  */
   10526                                               return 1557;
   10527                                             }
   10528                                           else
   10529                                             {
   10530                                               /* 33222222222211111111110000000000
   10531                                                  10987654321098765432109876543210
   10532                                                  100001x11xxxxxxx100xxxxxxxxxxxxx
   10533                                                  ld1rsb.  */
   10534                                               return 1554;
   10535                                             }
   10536                                         }
   10537                                     }
   10538                                   else
   10539                                     {
   10540                                       if (((word >> 15) & 0x1) == 0)
   10541                                         {
   10542                                           if (((word >> 23) & 0x1) == 0)
   10543                                             {
   10544                                               if (((word >> 21) & 0x1) == 0)
   10545                                                 {
   10546                                                   /* 33222222222211111111110000000000
   10547                                                      10987654321098765432109876543210
   10548                                                      100001x10x0xxxxx010xxxxxxxxxxxxx
   10549                                                      ld1w.  */
   10550                                                   return 1592;
   10551                                                 }
   10552                                               else
   10553                                                 {
   10554                                                   /* 33222222222211111111110000000000
   10555                                                      10987654321098765432109876543210
   10556                                                      100001x10x1xxxxx010xxxxxxxxxxxxx
   10557                                                      ld1w.  */
   10558                                                   return 1593;
   10559                                                 }
   10560                                             }
   10561                                           else
   10562                                             {
   10563                                               if (((word >> 22) & 0x1) == 0)
   10564                                                 {
   10565                                                   /* 33222222222211111111110000000000
   10566                                                      10987654321098765432109876543210
   10567                                                      100001x110xxxxxx010xxxxxxxxxxxxx
   10568                                                      ldr.  */
   10569                                                   return 1729;
   10570                                                 }
   10571                                               else
   10572                                                 {
   10573                                                   /* 33222222222211111111110000000000
   10574                                                      10987654321098765432109876543210
   10575                                                      100001x111xxxxxx010xxxxxxxxxxxxx
   10576                                                      prfw.  */
   10577                                                   return 1793;
   10578                                                 }
   10579                                             }
   10580                                         }
   10581                                       else
   10582                                         {
   10583                                           if (((word >> 22) & 0x1) == 0)
   10584                                             {
   10585                                               if (((word >> 21) & 0x1) == 0)
   10586                                                 {
   10587                                                   if (((word >> 23) & 0x1) == 0)
   10588                                                     {
   10589                                                       /* 33222222222211111111110000000000
   10590                                                          10987654321098765432109876543210
   10591                                                          100001x1000xxxxx110xxxxxxxxxxxxx
   10592                                                          prfw.  */
   10593                                                       return 1789;
   10594                                                     }
   10595                                                   else
   10596                                                     {
   10597                                                       /* 33222222222211111111110000000000
   10598                                                          10987654321098765432109876543210
   10599                                                          100001x1100xxxxx110xxxxxxxxxxxxx
   10600                                                          prfd.  */
   10601                                                       return 1775;
   10602                                                     }
   10603                                                 }
   10604                                               else
   10605                                                 {
   10606                                                   /* 33222222222211111111110000000000
   10607                                                      10987654321098765432109876543210
   10608                                                      100001x1x01xxxxx110xxxxxxxxxxxxx
   10609                                                      ld1w.  */
   10610                                                   return 1600;
   10611                                                 }
   10612                                             }
   10613                                           else
   10614                                             {
   10615                                               if (((word >> 23) & 0x1) == 0)
   10616                                                 {
   10617                                                   /* 33222222222211111111110000000000
   10618                                                      10987654321098765432109876543210
   10619                                                      100001x101xxxxxx110xxxxxxxxxxxxx
   10620                                                      ld1rw.  */
   10621                                                   return 1560;
   10622                                                 }
   10623                                               else
   10624                                                 {
   10625                                                   /* 33222222222211111111110000000000
   10626                                                      10987654321098765432109876543210
   10627                                                      100001x111xxxxxx110xxxxxxxxxxxxx
   10628                                                      ld1rsb.  */
   10629                                                   return 1556;
   10630                                                 }
   10631                                             }
   10632                                         }
   10633                                     }
   10634                                 }
   10635                               else
   10636                                 {
   10637                                   if (((word >> 14) & 0x1) == 0)
   10638                                     {
   10639                                       if (((word >> 15) & 0x1) == 0)
   10640                                         {
   10641                                           /* 33222222222211111111110000000000
   10642                                              10987654321098765432109876543210
   10643                                              100001x1xxxxxxxx001xxxxxxxxxxxxx
   10644                                              prfh.  */
   10645                                           return 1786;
   10646                                         }
   10647                                       else
   10648                                         {
   10649                                           if (((word >> 22) & 0x1) == 0)
   10650                                             {
   10651                                               /* 33222222222211111111110000000000
   10652                                                  10987654321098765432109876543210
   10653                                                  100001x1x0xxxxxx101xxxxxxxxxxxxx
   10654                                                  ldnt1w.  */
   10655                                               return 2100;
   10656                                             }
   10657                                           else
   10658                                             {
   10659                                               if (((word >> 23) & 0x1) == 0)
   10660                                                 {
   10661                                                   /* 33222222222211111111110000000000
   10662                                                      10987654321098765432109876543210
   10663                                                      100001x101xxxxxx101xxxxxxxxxxxxx
   10664                                                      ld1rsh.  */
   10665                                                   return 1558;
   10666                                                 }
   10667                                               else
   10668                                                 {
   10669                                                   /* 33222222222211111111110000000000
   10670                                                      10987654321098765432109876543210
   10671                                                      100001x111xxxxxx101xxxxxxxxxxxxx
   10672                                                      ld1rsb.  */
   10673                                                   return 1555;
   10674                                                 }
   10675                                             }
   10676                                         }
   10677                                     }
   10678                                   else
   10679                                     {
   10680                                       if (((word >> 15) & 0x1) == 0)
   10681                                         {
   10682                                           if (((word >> 23) & 0x1) == 0)
   10683                                             {
   10684                                               if (((word >> 21) & 0x1) == 0)
   10685                                                 {
   10686                                                   /* 33222222222211111111110000000000
   10687                                                      10987654321098765432109876543210
   10688                                                      100001x10x0xxxxx011xxxxxxxxxxxxx
   10689                                                      ldff1w.  */
   10690                                                   return 1692;
   10691                                                 }
   10692                                               else
   10693                                                 {
   10694                                                   /* 33222222222211111111110000000000
   10695                                                      10987654321098765432109876543210
   10696                                                      100001x10x1xxxxx011xxxxxxxxxxxxx
   10697                                                      ldff1w.  */
   10698                                                   return 1693;
   10699                                                 }
   10700                                             }
   10701                                           else
   10702                                             {
   10703                                               /* 33222222222211111111110000000000
   10704                                                  10987654321098765432109876543210
   10705                                                  100001x11xxxxxxx011xxxxxxxxxxxxx
   10706                                                  prfd.  */
   10707                                               return 1779;
   10708                                             }
   10709                                         }
   10710                                       else
   10711                                         {
   10712                                           if (((word >> 22) & 0x1) == 0)
   10713                                             {
   10714                                               if (((word >> 21) & 0x1) == 0)
   10715                                                 {
   10716                                                   if (((word >> 23) & 0x1) == 0)
   10717                                                     {
   10718                                                       /* 33222222222211111111110000000000
   10719                                                          10987654321098765432109876543210
   10720                                                          100001x1000xxxxx111xxxxxxxxxxxxx
   10721                                                          prfw.  */
   10722                                                       return 1792;
   10723                                                     }
   10724                                                   else
   10725                                                     {
   10726                                                       /* 33222222222211111111110000000000
   10727                                                          10987654321098765432109876543210
   10728                                                          100001x1100xxxxx111xxxxxxxxxxxxx
   10729                                                          prfd.  */
   10730                                                       return 1778;
   10731                                                     }
   10732                                                 }
   10733                                               else
   10734                                                 {
   10735                                                   /* 33222222222211111111110000000000
   10736                                                      10987654321098765432109876543210
   10737                                                      100001x1x01xxxxx111xxxxxxxxxxxxx
   10738                                                      ldff1w.  */
   10739                                                   return 1702;
   10740                                                 }
   10741                                             }
   10742                                           else
   10743                                             {
   10744                                               if (((word >> 23) & 0x1) == 0)
   10745                                                 {
   10746                                                   /* 33222222222211111111110000000000
   10747                                                      10987654321098765432109876543210
   10748                                                      100001x101xxxxxx111xxxxxxxxxxxxx
   10749                                                      ld1rw.  */
   10750                                                   return 1561;
   10751                                                 }
   10752                                               else
   10753                                                 {
   10754                                                   /* 33222222222211111111110000000000
   10755                                                      10987654321098765432109876543210
   10756                                                      100001x111xxxxxx111xxxxxxxxxxxxx
   10757                                                      ld1rd.  */
   10758                                                   return 1542;
   10759                                                 }
   10760                                             }
   10761                                         }
   10762                                     }
   10763                                 }
   10764                             }
   10765                         }
   10766                       else
   10767                         {
   10768                           if (((word >> 13) & 0x1) == 0)
   10769                             {
   10770                               if (((word >> 14) & 0x1) == 0)
   10771                                 {
   10772                                   if (((word >> 15) & 0x1) == 0)
   10773                                     {
   10774                                       if (((word >> 21) & 0x1) == 0)
   10775                                         {
   10776                                           if (((word >> 31) & 0x1) == 0)
   10777                                             {
   10778                                               if (((word >> 10) & 0x1) == 0)
   10779                                                 {
   10780                                                   if (((word >> 11) & 0x1) == 0)
   10781                                                     {
   10782                                                       if (((word >> 12) & 0x1) == 0)
   10783                                                         {
   10784                                                           /* 33222222222211111111110000000000
   10785                                                              10987654321098765432109876543210
   10786                                                              010001x1xx0xxxxx000000xxxxxxxxxx
   10787                                                              saddlb.  */
   10788                                                           return 2130;
   10789                                                         }
   10790                                                       else
   10791                                                         {
   10792                                                           /* 33222222222211111111110000000000
   10793                                                              10987654321098765432109876543210
   10794                                                              010001x1xx0xxxxx000100xxxxxxxxxx
   10795                                                              ssublb.  */
   10796                                                           return 2237;
   10797                                                         }
   10798                                                     }
   10799                                                   else
   10800                                                     {
   10801                                                       if (((word >> 12) & 0x1) == 0)
   10802                                                         {
   10803                                                           /* 33222222222211111111110000000000
   10804                                                              10987654321098765432109876543210
   10805                                                              010001x1xx0xxxxx000010xxxxxxxxxx
   10806                                                              uaddlb.  */
   10807                                                           return 2261;
   10808                                                         }
   10809                                                       else
   10810                                                         {
   10811                                                           /* 33222222222211111111110000000000
   10812                                                              10987654321098765432109876543210
   10813                                                              010001x1xx0xxxxx000110xxxxxxxxxx
   10814                                                              usublb.  */
   10815                                                           return 2314;
   10816                                                         }
   10817                                                     }
   10818                                                 }
   10819                                               else
   10820                                                 {
   10821                                                   if (((word >> 11) & 0x1) == 0)
   10822                                                     {
   10823                                                       if (((word >> 12) & 0x1) == 0)
   10824                                                         {
   10825                                                           /* 33222222222211111111110000000000
   10826                                                              10987654321098765432109876543210
   10827                                                              010001x1xx0xxxxx000001xxxxxxxxxx
   10828                                                              saddlt.  */
   10829                                                           return 2132;
   10830                                                         }
   10831                                                       else
   10832                                                         {
   10833                                                           /* 33222222222211111111110000000000
   10834                                                              10987654321098765432109876543210
   10835                                                              010001x1xx0xxxxx000101xxxxxxxxxx
   10836                                                              ssublt.  */
   10837                                                           return 2239;
   10838                                                         }
   10839                                                     }
   10840                                                   else
   10841                                                     {
   10842                                                       if (((word >> 12) & 0x1) == 0)
   10843                                                         {
   10844                                                           /* 33222222222211111111110000000000
   10845                                                              10987654321098765432109876543210
   10846                                                              010001x1xx0xxxxx000011xxxxxxxxxx
   10847                                                              uaddlt.  */
   10848                                                           return 2262;
   10849                                                         }
   10850                                                       else
   10851                                                         {
   10852                                                           /* 33222222222211111111110000000000
   10853                                                              10987654321098765432109876543210
   10854                                                              010001x1xx0xxxxx000111xxxxxxxxxx
   10855                                                              usublt.  */
   10856                                                           return 2315;
   10857                                                         }
   10858                                                     }
   10859                                                 }
   10860                                             }
   10861                                           else
   10862                                             {
   10863                                               /* 33222222222211111111110000000000
   10864                                                  10987654321098765432109876543210
   10865                                                  110001x1xx0xxxxx000xxxxxxxxxxxxx
   10866                                                  ld1sw.  */
   10867                                               return 1586;
   10868                                             }
   10869                                         }
   10870                                       else
   10871                                         {
   10872                                           if (((word >> 31) & 0x1) == 0)
   10873                                             {
   10874                                               if (((word >> 10) & 0x1) == 0)
   10875                                                 {
   10876                                                   if (((word >> 11) & 0x1) == 0)
   10877                                                     {
   10878                                                       if (((word >> 12) & 0x1) == 0)
   10879                                                         {
   10880                                                           /* 33222222222211111111110000000000
   10881                                                              10987654321098765432109876543210
   10882                                                              010001x1xx1xxxxx000000xxxxxxxxxx
   10883                                                              sqshrunb.  */
   10884                                                           return 2220;
   10885                                                         }
   10886                                                       else
   10887                                                         {
   10888                                                           /* 33222222222211111111110000000000
   10889                                                              10987654321098765432109876543210
   10890                                                              010001x1xx1xxxxx000100xxxxxxxxxx
   10891                                                              shrnb.  */
   10892                                                           return 2138;
   10893                                                         }
   10894                                                     }
   10895                                                   else
   10896                                                     {
   10897                                                       if (((word >> 12) & 0x1) == 0)
   10898                                                         {
   10899                                                           /* 33222222222211111111110000000000
   10900                                                              10987654321098765432109876543210
   10901                                                              010001x1xx1xxxxx000010xxxxxxxxxx
   10902                                                              sqrshrunb.  */
   10903                                                           return 2212;
   10904                                                         }
   10905                                                       else
   10906                                                         {
   10907                                                           /* 33222222222211111111110000000000
   10908                                                              10987654321098765432109876543210
   10909                                                              010001x1xx1xxxxx000110xxxxxxxxxx
   10910                                                              rshrnb.  */
   10911                                                           return 2120;
   10912                                                         }
   10913                                                     }
   10914                                                 }
   10915                                               else
   10916                                                 {
   10917                                                   if (((word >> 11) & 0x1) == 0)
   10918                                                     {
   10919                                                       if (((word >> 12) & 0x1) == 0)
   10920                                                         {
   10921                                                           /* 33222222222211111111110000000000
   10922                                                              10987654321098765432109876543210
   10923                                                              010001x1xx1xxxxx000001xxxxxxxxxx
   10924                                                              sqshrunt.  */
   10925                                                           return 2221;
   10926                                                         }
   10927                                                       else
   10928                                                         {
   10929                                                           /* 33222222222211111111110000000000
   10930                                                              10987654321098765432109876543210
   10931                                                              010001x1xx1xxxxx000101xxxxxxxxxx
   10932                                                              shrnt.  */
   10933                                                           return 2139;
   10934                                                         }
   10935                                                     }
   10936                                                   else
   10937                                                     {
   10938                                                       if (((word >> 12) & 0x1) == 0)
   10939                                                         {
   10940                                                           /* 33222222222211111111110000000000
   10941                                                              10987654321098765432109876543210
   10942                                                              010001x1xx1xxxxx000011xxxxxxxxxx
   10943                                                              sqrshrunt.  */
   10944                                                           return 2213;
   10945                                                         }
   10946                                                       else
   10947                                                         {
   10948                                                           /* 33222222222211111111110000000000
   10949                                                              10987654321098765432109876543210
   10950                                                              010001x1xx1xxxxx000111xxxxxxxxxx
   10951                                                              rshrnt.  */
   10952                                                           return 2121;
   10953                                                         }
   10954                                                     }
   10955                                                 }
   10956                                             }
   10957                                           else
   10958                                             {
   10959                                               /* 33222222222211111111110000000000
   10960                                                  10987654321098765432109876543210
   10961                                                  110001x1xx1xxxxx000xxxxxxxxxxxxx
   10962                                                  ld1sw.  */
   10963                                               return 1587;
   10964                                             }
   10965                                         }
   10966                                     }
   10967                                   else
   10968                                     {
   10969                                       if (((word >> 21) & 0x1) == 0)
   10970                                         {
   10971                                           if (((word >> 31) & 0x1) == 0)
   10972                                             {
   10973                                               if (((word >> 10) & 0x1) == 0)
   10974                                                 {
   10975                                                   if (((word >> 11) & 0x1) == 0)
   10976                                                     {
   10977                                                       if (((word >> 12) & 0x1) == 0)
   10978                                                         {
   10979                                                           /* 33222222222211111111110000000000
   10980                                                              10987654321098765432109876543210
   10981                                                              010001x1xx0xxxxx100000xxxxxxxxxx
   10982                                                              saddlbt.  */
   10983                                                           return 2131;
   10984                                                         }
   10985                                                       else
   10986                                                         {
   10987                                                           /* 33222222222211111111110000000000
   10988                                                              10987654321098765432109876543210
   10989                                                              010001x1xx0xxxxx100100xxxxxxxxxx
   10990                                                              eorbt.  */
   10991                                                           return 2067;
   10992                                                         }
   10993                                                     }
   10994                                                   else
   10995                                                     {
   10996                                                       if (((word >> 12) & 0x1) == 0)
   10997                                                         {
   10998                                                           /* 33222222222211111111110000000000
   10999                                                              10987654321098765432109876543210
   11000                                                              010001x1xx0xxxxx100010xxxxxxxxxx
   11001                                                              ssublbt.  */
   11002                                                           return 2238;
   11003                                                         }
   11004                                                       else
   11005                                                         {
   11006                                                           if (((word >> 22) & 0x1) == 0)
   11007                                                             {
   11008                                                               if (((word >> 23) & 0x1) == 0)
   11009                                                                 {
   11010                                                                   /* 33222222222211111111110000000000
   11011                                                                      10987654321098765432109876543210
   11012                                                                      010001x1000xxxxx100110xxxxxxxxxx
   11013                                                                      smmla.  */
   11014                                                                   return 2394;
   11015                                                                 }
   11016                                                               else
   11017                                                                 {
   11018                                                                   /* 33222222222211111111110000000000
   11019                                                                      10987654321098765432109876543210
   11020                                                                      010001x1100xxxxx100110xxxxxxxxxx
   11021                                                                      usmmla.  */
   11022                                                                   return 2396;
   11023                                                                 }
   11024                                                             }
   11025                                                           else
   11026                                                             {
   11027                                                               /* 33222222222211111111110000000000
   11028                                                                  10987654321098765432109876543210
   11029                                                                  010001x1x10xxxxx100110xxxxxxxxxx
   11030                                                                  ummla.  */
   11031                                                               return 2395;
   11032                                                             }
   11033                                                         }
   11034                                                     }
   11035                                                 }
   11036                                               else
   11037                                                 {
   11038                                                   if (((word >> 11) & 0x1) == 0)
   11039                                                     {
   11040                                                       /* 33222222222211111111110000000000
   11041                                                          10987654321098765432109876543210
   11042                                                          010001x1xx0xxxxx100x01xxxxxxxxxx
   11043                                                          eortb.  */
   11044                                                       return 2068;
   11045                                                     }
   11046                                                   else
   11047                                                     {
   11048                                                       /* 33222222222211111111110000000000
   11049                                                          10987654321098765432109876543210
   11050                                                          010001x1xx0xxxxx100x11xxxxxxxxxx
   11051                                                          ssubltb.  */
   11052                                                       return 2240;
   11053                                                     }
   11054                                                 }
   11055                                             }
   11056                                           else
   11057                                             {
   11058                                               if (((word >> 22) & 0x1) == 0)
   11059                                                 {
   11060                                                   /* 33222222222211111111110000000000
   11061                                                      10987654321098765432109876543210
   11062                                                      110001x1x00xxxxx100xxxxxxxxxxxxx
   11063                                                      ldnt1sw.  */
   11064                                                   return 2099;
   11065                                                 }
   11066                                               else
   11067                                                 {
   11068                                                   /* 33222222222211111111110000000000
   11069                                                      10987654321098765432109876543210
   11070                                                      110001x1x10xxxxx100xxxxxxxxxxxxx
   11071                                                      ld1sw.  */
   11072                                                   return 1588;
   11073                                                 }
   11074                                             }
   11075                                         }
   11076                                       else
   11077                                         {
   11078                                           if (((word >> 31) & 0x1) == 0)
   11079                                             {
   11080                                               if (((word >> 4) & 0x1) == 0)
   11081                                                 {
   11082                                                   /* 33222222222211111111110000000000
   11083                                                      10987654321098765432109876543210
   11084                                                      010001x1xx1xxxxx100xxxxxxxx0xxxx
   11085                                                      match.  */
   11086                                                   return 2102;
   11087                                                 }
   11088                                               else
   11089                                                 {
   11090                                                   /* 33222222222211111111110000000000
   11091                                                      10987654321098765432109876543210
   11092                                                      010001x1xx1xxxxx100xxxxxxxx1xxxx
   11093                                                      nmatch.  */
   11094                                                   return 2114;
   11095                                                 }
   11096                                             }
   11097                                           else
   11098                                             {
   11099                                               if (((word >> 22) & 0x1) == 0)
   11100                                                 {
   11101                                                   /* 33222222222211111111110000000000
   11102                                                      10987654321098765432109876543210
   11103                                                      110001x1x01xxxxx100xxxxxxxxxxxxx
   11104                                                      ld1sw.  */
   11105                                                   return 1591;
   11106                                                 }
   11107                                               else
   11108                                                 {
   11109                                                   /* 33222222222211111111110000000000
   11110                                                      10987654321098765432109876543210
   11111                                                      110001x1x11xxxxx100xxxxxxxxxxxxx
   11112                                                      ld1sw.  */
   11113                                                   return 1589;
   11114                                                 }
   11115                                             }
   11116                                         }
   11117                                     }
   11118                                 }
   11119                               else
   11120                                 {
   11121                                   if (((word >> 15) & 0x1) == 0)
   11122                                     {
   11123                                       if (((word >> 21) & 0x1) == 0)
   11124                                         {
   11125                                           if (((word >> 31) & 0x1) == 0)
   11126                                             {
   11127                                               if (((word >> 10) & 0x1) == 0)
   11128                                                 {
   11129                                                   if (((word >> 11) & 0x1) == 0)
   11130                                                     {
   11131                                                       if (((word >> 12) & 0x1) == 0)
   11132                                                         {
   11133                                                           /* 33222222222211111111110000000000
   11134                                                              10987654321098765432109876543210
   11135                                                              010001x1xx0xxxxx010000xxxxxxxxxx
   11136                                                              saddwb.  */
   11137                                                           return 2133;
   11138                                                         }
   11139                                                       else
   11140                                                         {
   11141                                                           /* 33222222222211111111110000000000
   11142                                                              10987654321098765432109876543210
   11143                                                              010001x1xx0xxxxx010100xxxxxxxxxx
   11144                                                              ssubwb.  */
   11145                                                           return 2241;
   11146                                                         }
   11147                                                     }
   11148                                                   else
   11149                                                     {
   11150                                                       if (((word >> 12) & 0x1) == 0)
   11151                                                         {
   11152                                                           /* 33222222222211111111110000000000
   11153                                                              10987654321098765432109876543210
   11154                                                              010001x1xx0xxxxx010010xxxxxxxxxx
   11155                                                              uaddwb.  */
   11156                                                           return 2263;
   11157                                                         }
   11158                                                       else
   11159                                                         {
   11160                                                           /* 33222222222211111111110000000000
   11161                                                              10987654321098765432109876543210
   11162                                                              010001x1xx0xxxxx010110xxxxxxxxxx
   11163                                                              usubwb.  */
   11164                                                           return 2316;
   11165                                                         }
   11166                                                     }
   11167                                                 }
   11168                                               else
   11169                                                 {
   11170                                                   if (((word >> 11) & 0x1) == 0)
   11171                                                     {
   11172                                                       if (((word >> 12) & 0x1) == 0)
   11173                                                         {
   11174                                                           /* 33222222222211111111110000000000
   11175                                                              10987654321098765432109876543210
   11176                                                              010001x1xx0xxxxx010001xxxxxxxxxx
   11177                                                              saddwt.  */
   11178                                                           return 2134;
   11179                                                         }
   11180                                                       else
   11181                                                         {
   11182                                                           /* 33222222222211111111110000000000
   11183                                                              10987654321098765432109876543210
   11184                                                              010001x1xx0xxxxx010101xxxxxxxxxx
   11185                                                              ssubwt.  */
   11186                                                           return 2242;
   11187                                                         }
   11188                                                     }
   11189                                                   else
   11190                                                     {
   11191                                                       if (((word >> 12) & 0x1) == 0)
   11192                                                         {
   11193                                                           /* 33222222222211111111110000000000
   11194                                                              10987654321098765432109876543210
   11195                                                              010001x1xx0xxxxx010011xxxxxxxxxx
   11196                                                              uaddwt.  */
   11197                                                           return 2264;
   11198                                                         }
   11199                                                       else
   11200                                                         {
   11201                                                           /* 33222222222211111111110000000000
   11202                                                              10987654321098765432109876543210
   11203                                                              010001x1xx0xxxxx010111xxxxxxxxxx
   11204                                                              usubwt.  */
   11205                                                           return 2317;
   11206                                                         }
   11207                                                     }
   11208                                                 }
   11209                                             }
   11210                                           else
   11211                                             {
   11212                                               if (((word >> 23) & 0x1) == 0)
   11213                                                 {
   11214                                                   /* 33222222222211111111110000000000
   11215                                                      10987654321098765432109876543210
   11216                                                      110001x10x0xxxxx010xxxxxxxxxxxxx
   11217                                                      ld1w.  */
   11218                                                   return 1596;
   11219                                                 }
   11220                                               else
   11221                                                 {
   11222                                                   /* 33222222222211111111110000000000
   11223                                                      10987654321098765432109876543210
   11224                                                      110001x11x0xxxxx010xxxxxxxxxxxxx
   11225                                                      ld1d.  */
   11226                                                   return 1518;
   11227                                                 }
   11228                                             }
   11229                                         }
   11230                                       else
   11231                                         {
   11232                                           if (((word >> 23) & 0x1) == 0)
   11233                                             {
   11234                                               if (((word >> 31) & 0x1) == 0)
   11235                                                 {
   11236                                                   if (((word >> 10) & 0x1) == 0)
   11237                                                     {
   11238                                                       if (((word >> 11) & 0x1) == 0)
   11239                                                         {
   11240                                                           if (((word >> 12) & 0x1) == 0)
   11241                                                             {
   11242                                                               /* 33222222222211111111110000000000
   11243                                                                  10987654321098765432109876543210
   11244                                                                  010001x10x1xxxxx010000xxxxxxxxxx
   11245                                                                  sqxtnb.  */
   11246                                                               return 2224;
   11247                                                             }
   11248                                                           else
   11249                                                             {
   11250                                                               /* 33222222222211111111110000000000
   11251                                                                  10987654321098765432109876543210
   11252                                                                  010001x10x1xxxxx010100xxxxxxxxxx
   11253                                                                  sqxtunb.  */
   11254                                                               return 2226;
   11255                                                             }
   11256                                                         }
   11257                                                       else
   11258                                                         {
   11259                                                           /* 33222222222211111111110000000000
   11260                                                              10987654321098765432109876543210
   11261                                                              010001x10x1xxxxx010x10xxxxxxxxxx
   11262                                                              uqxtnb.  */
   11263                                                           return 2301;
   11264                                                         }
   11265                                                     }
   11266                                                   else
   11267                                                     {
   11268                                                       if (((word >> 11) & 0x1) == 0)
   11269                                                         {
   11270                                                           if (((word >> 12) & 0x1) == 0)
   11271                                                             {
   11272                                                               /* 33222222222211111111110000000000
   11273                                                                  10987654321098765432109876543210
   11274                                                                  010001x10x1xxxxx010001xxxxxxxxxx
   11275                                                                  sqxtnt.  */
   11276                                                               return 2225;
   11277                                                             }
   11278                                                           else
   11279                                                             {
   11280                                                               /* 33222222222211111111110000000000
   11281                                                                  10987654321098765432109876543210
   11282                                                                  010001x10x1xxxxx010101xxxxxxxxxx
   11283                                                                  sqxtunt.  */
   11284                                                               return 2227;
   11285                                                             }
   11286                                                         }
   11287                                                       else
   11288                                                         {
   11289                                                           /* 33222222222211111111110000000000
   11290                                                              10987654321098765432109876543210
   11291                                                              010001x10x1xxxxx010x11xxxxxxxxxx
   11292                                                              uqxtnt.  */
   11293                                                           return 2302;
   11294                                                         }
   11295                                                     }
   11296                                                 }
   11297                                               else
   11298                                                 {
   11299                                                   /* 33222222222211111111110000000000
   11300                                                      10987654321098765432109876543210
   11301                                                      110001x10x1xxxxx010xxxxxxxxxxxxx
   11302                                                      ld1w.  */
   11303                                                   return 1597;
   11304                                                 }
   11305                                             }
   11306                                           else
   11307                                             {
   11308                                               /* 33222222222211111111110000000000
   11309                                                  10987654321098765432109876543210
   11310                                                  x10001x11x1xxxxx010xxxxxxxxxxxxx
   11311                                                  ld1d.  */
   11312                                               return 1519;
   11313                                             }
   11314                                         }
   11315                                     }
   11316                                   else
   11317                                     {
   11318                                       if (((word >> 21) & 0x1) == 0)
   11319                                         {
   11320                                           if (((word >> 31) & 0x1) == 0)
   11321                                             {
   11322                                               if (((word >> 11) & 0x1) == 0)
   11323                                                 {
   11324                                                   if (((word >> 10) & 0x1) == 0)
   11325                                                     {
   11326                                                       if (((word >> 12) & 0x1) == 0)
   11327                                                         {
   11328                                                           /* 33222222222211111111110000000000
   11329                                                              10987654321098765432109876543210
   11330                                                              010001x1xx0xxxxx110000xxxxxxxxxx
   11331                                                              sabalb.  */
   11332                                                           return 2125;
   11333                                                         }
   11334                                                       else
   11335                                                         {
   11336                                                           if (((word >> 23) & 0x1) == 0)
   11337                                                             {
   11338                                                               /* 33222222222211111111110000000000
   11339                                                                  10987654321098765432109876543210
   11340                                                                  010001x10x0xxxxx110100xxxxxxxxxx
   11341                                                                  adclb.  */
   11342                                                               return 2050;
   11343                                                             }
   11344                                                           else
   11345                                                             {
   11346                                                               /* 33222222222211111111110000000000
   11347                                                                  10987654321098765432109876543210
   11348                                                                  010001x11x0xxxxx110100xxxxxxxxxx
   11349                                                                  sbclb.  */
   11350                                                               return 2135;
   11351                                                             }
   11352                                                         }
   11353                                                     }
   11354                                                   else
   11355                                                     {
   11356                                                       if (((word >> 12) & 0x1) == 0)
   11357                                                         {
   11358                                                           /* 33222222222211111111110000000000
   11359                                                              10987654321098765432109876543210
   11360                                                              010001x1xx0xxxxx110001xxxxxxxxxx
   11361                                                              sabalt.  */
   11362                                                           return 2126;
   11363                                                         }
   11364                                                       else
   11365                                                         {
   11366                                                           if (((word >> 23) & 0x1) == 0)
   11367                                                             {
   11368                                                               /* 33222222222211111111110000000000
   11369                                                                  10987654321098765432109876543210
   11370                                                                  010001x10x0xxxxx110101xxxxxxxxxx
   11371                                                                  adclt.  */
   11372                                                               return 2051;
   11373                                                             }
   11374                                                           else
   11375                                                             {
   11376                                                               /* 33222222222211111111110000000000
   11377                                                                  10987654321098765432109876543210
   11378                                                                  010001x11x0xxxxx110101xxxxxxxxxx
   11379                                                                  sbclt.  */
   11380                                                               return 2136;
   11381                                                             }
   11382                                                         }
   11383                                                     }
   11384                                                 }
   11385                                               else
   11386                                                 {
   11387                                                   if (((word >> 12) & 0x1) == 0)
   11388                                                     {
   11389                                                       if (((word >> 10) & 0x1) == 0)
   11390                                                         {
   11391                                                           /* 33222222222211111111110000000000
   11392                                                              10987654321098765432109876543210
   11393                                                              010001x1xx0xxxxx110010xxxxxxxxxx
   11394                                                              uabalb.  */
   11395                                                           return 2256;
   11396                                                         }
   11397                                                       else
   11398                                                         {
   11399                                                           /* 33222222222211111111110000000000
   11400                                                              10987654321098765432109876543210
   11401                                                              010001x1xx0xxxxx110011xxxxxxxxxx
   11402                                                              uabalt.  */
   11403                                                           return 2257;
   11404                                                         }
   11405                                                     }
   11406                                                   else
   11407                                                     {
   11408                                                       if (((word >> 16) & 0x1) == 0)
   11409                                                         {
   11410                                                           /* 33222222222211111111110000000000
   11411                                                              10987654321098765432109876543210
   11412                                                              010001x1xx0xxxx011011xxxxxxxxxxx
   11413                                                              cadd.  */
   11414                                                           return 2059;
   11415                                                         }
   11416                                                       else
   11417                                                         {
   11418                                                           /* 33222222222211111111110000000000
   11419                                                              10987654321098765432109876543210
   11420                                                              010001x1xx0xxxx111011xxxxxxxxxxx
   11421                                                              sqcadd.  */
   11422                                                           return 2167;
   11423                                                         }
   11424                                                     }
   11425                                                 }
   11426                                             }
   11427                                           else
   11428                                             {
   11429                                               if (((word >> 22) & 0x1) == 0)
   11430                                                 {
   11431                                                   if (((word >> 23) & 0x1) == 0)
   11432                                                     {
   11433                                                       /* 33222222222211111111110000000000
   11434                                                          10987654321098765432109876543210
   11435                                                          110001x1000xxxxx110xxxxxxxxxxxxx
   11436                                                          ldnt1w.  */
   11437                                                       return 2101;
   11438                                                     }
   11439                                                   else
   11440                                                     {
   11441                                                       /* 33222222222211111111110000000000
   11442                                                          10987654321098765432109876543210
   11443                                                          110001x1100xxxxx110xxxxxxxxxxxxx
   11444                                                          ldnt1d.  */
   11445                                                       return 2094;
   11446                                                     }
   11447                                                 }
   11448                                               else
   11449                                                 {
   11450                                                   if (((word >> 23) & 0x1) == 0)
   11451                                                     {
   11452                                                       /* 33222222222211111111110000000000
   11453                                                          10987654321098765432109876543210
   11454                                                          110001x1010xxxxx110xxxxxxxxxxxxx
   11455                                                          ld1w.  */
   11456                                                       return 1598;
   11457                                                     }
   11458                                                   else
   11459                                                     {
   11460                                                       /* 33222222222211111111110000000000
   11461                                                          10987654321098765432109876543210
   11462                                                          110001x1110xxxxx110xxxxxxxxxxxxx
   11463                                                          ld1d.  */
   11464                                                       return 1520;
   11465                                                     }
   11466                                                 }
   11467                                             }
   11468                                         }
   11469                                       else
   11470                                         {
   11471                                           if (((word >> 23) & 0x1) == 0)
   11472                                             {
   11473                                               if (((word >> 22) & 0x1) == 0)
   11474                                                 {
   11475                                                   /* 33222222222211111111110000000000
   11476                                                      10987654321098765432109876543210
   11477                                                      x10001x1001xxxxx110xxxxxxxxxxxxx
   11478                                                      ld1w.  */
   11479                                                   return 1603;
   11480                                                 }
   11481                                               else
   11482                                                 {
   11483                                                   /* 33222222222211111111110000000000
   11484                                                      10987654321098765432109876543210
   11485                                                      x10001x1011xxxxx110xxxxxxxxxxxxx
   11486                                                      ld1w.  */
   11487                                                   return 1599;
   11488                                                 }
   11489                                             }
   11490                                           else
   11491                                             {
   11492                                               if (((word >> 31) & 0x1) == 0)
   11493                                                 {
   11494                                                   /* 33222222222211111111110000000000
   11495                                                      10987654321098765432109876543210
   11496                                                      010001x11x1xxxxx110xxxxxxxxxxxxx
   11497                                                      histcnt.  */
   11498                                                   return 2090;
   11499                                                 }
   11500                                               else
   11501                                                 {
   11502                                                   if (((word >> 22) & 0x1) == 0)
   11503                                                     {
   11504                                                       /* 33222222222211111111110000000000
   11505                                                          10987654321098765432109876543210
   11506                                                          110001x1101xxxxx110xxxxxxxxxxxxx
   11507                                                          ld1d.  */
   11508                                                       return 1523;
   11509                                                     }
   11510                                                   else
   11511                                                     {
   11512                                                       /* 33222222222211111111110000000000
   11513                                                          10987654321098765432109876543210
   11514                                                          110001x1111xxxxx110xxxxxxxxxxxxx
   11515                                                          ld1d.  */
   11516                                                       return 1521;
   11517                                                     }
   11518                                                 }
   11519                                             }
   11520                                         }
   11521                                     }
   11522                                 }
   11523                             }
   11524                           else
   11525                             {
   11526                               if (((word >> 14) & 0x1) == 0)
   11527                                 {
   11528                                   if (((word >> 15) & 0x1) == 0)
   11529                                     {
   11530                                       if (((word >> 21) & 0x1) == 0)
   11531                                         {
   11532                                           if (((word >> 31) & 0x1) == 0)
   11533                                             {
   11534                                               if (((word >> 10) & 0x1) == 0)
   11535                                                 {
   11536                                                   if (((word >> 11) & 0x1) == 0)
   11537                                                     {
   11538                                                       /* 33222222222211111111110000000000
   11539                                                          10987654321098765432109876543210
   11540                                                          010001x1xx0xxxxx001x00xxxxxxxxxx
   11541                                                          sabdlb.  */
   11542                                                       return 2127;
   11543                                                     }
   11544                                                   else
   11545                                                     {
   11546                                                       /* 33222222222211111111110000000000
   11547                                                          10987654321098765432109876543210
   11548                                                          010001x1xx0xxxxx001x10xxxxxxxxxx
   11549                                                          uabdlb.  */
   11550                                                       return 2258;
   11551                                                     }
   11552                                                 }
   11553                                               else
   11554                                                 {
   11555                                                   if (((word >> 11) & 0x1) == 0)
   11556                                                     {
   11557                                                       /* 33222222222211111111110000000000
   11558                                                          10987654321098765432109876543210
   11559                                                          010001x1xx0xxxxx001x01xxxxxxxxxx
   11560                                                          sabdlt.  */
   11561                                                       return 2128;
   11562                                                     }
   11563                                                   else
   11564                                                     {
   11565                                                       /* 33222222222211111111110000000000
   11566                                                          10987654321098765432109876543210
   11567                                                          010001x1xx0xxxxx001x11xxxxxxxxxx
   11568                                                          uabdlt.  */
   11569                                                       return 2259;
   11570                                                     }
   11571                                                 }
   11572                                             }
   11573                                           else
   11574                                             {
   11575                                               /* 33222222222211111111110000000000
   11576                                                  10987654321098765432109876543210
   11577                                                  110001x1xx0xxxxx001xxxxxxxxxxxxx
   11578                                                  ldff1sw.  */
   11579                                               return 1687;
   11580                                             }
   11581                                         }
   11582                                       else
   11583                                         {
   11584                                           if (((word >> 31) & 0x1) == 0)
   11585                                             {
   11586                                               if (((word >> 10) & 0x1) == 0)
   11587                                                 {
   11588                                                   if (((word >> 11) & 0x1) == 0)
   11589                                                     {
   11590                                                       if (((word >> 12) & 0x1) == 0)
   11591                                                         {
   11592                                                           /* 33222222222211111111110000000000
   11593                                                              10987654321098765432109876543210
   11594                                                              010001x1xx1xxxxx001000xxxxxxxxxx
   11595                                                              sqshrnb.  */
   11596                                                           return 2218;
   11597                                                         }
   11598                                                       else
   11599                                                         {
   11600                                                           /* 33222222222211111111110000000000
   11601                                                              10987654321098765432109876543210
   11602                                                              010001x1xx1xxxxx001100xxxxxxxxxx
   11603                                                              uqshrnb.  */
   11604                                                           return 2297;
   11605                                                         }
   11606                                                     }
   11607                                                   else
   11608                                                     {
   11609                                                       if (((word >> 12) & 0x1) == 0)
   11610                                                         {
   11611                                                           /* 33222222222211111111110000000000
   11612                                                              10987654321098765432109876543210
   11613                                                              010001x1xx1xxxxx001010xxxxxxxxxx
   11614                                                              sqrshrnb.  */
   11615                                                           return 2210;
   11616                                                         }
   11617                                                       else
   11618                                                         {
   11619                                                           /* 33222222222211111111110000000000
   11620                                                              10987654321098765432109876543210
   11621                                                              010001x1xx1xxxxx001110xxxxxxxxxx
   11622                                                              uqrshrnb.  */
   11623                                                           return 2292;
   11624                                                         }
   11625                                                     }
   11626                                                 }
   11627                                               else
   11628                                                 {
   11629                                                   if (((word >> 11) & 0x1) == 0)
   11630                                                     {
   11631                                                       if (((word >> 12) & 0x1) == 0)
   11632                                                         {
   11633                                                           /* 33222222222211111111110000000000
   11634                                                              10987654321098765432109876543210
   11635                                                              010001x1xx1xxxxx001001xxxxxxxxxx
   11636                                                              sqshrnt.  */
   11637                                                           return 2219;
   11638                                                         }
   11639                                                       else
   11640                                                         {
   11641                                                           /* 33222222222211111111110000000000
   11642                                                              10987654321098765432109876543210
   11643                                                              010001x1xx1xxxxx001101xxxxxxxxxx
   11644                                                              uqshrnt.  */
   11645                                                           return 2298;
   11646                                                         }
   11647                                                     }
   11648                                                   else
   11649                                                     {
   11650                                                       if (((word >> 12) & 0x1) == 0)
   11651                                                         {
   11652                                                           /* 33222222222211111111110000000000
   11653                                                              10987654321098765432109876543210
   11654                                                              010001x1xx1xxxxx001011xxxxxxxxxx
   11655                                                              sqrshrnt.  */
   11656                                                           return 2211;
   11657                                                         }
   11658                                                       else
   11659                                                         {
   11660                                                           /* 33222222222211111111110000000000
   11661                                                              10987654321098765432109876543210
   11662                                                              010001x1xx1xxxxx001111xxxxxxxxxx
   11663                                                              uqrshrnt.  */
   11664                                                           return 2293;
   11665                                                         }
   11666                                                     }
   11667                                                 }
   11668                                             }
   11669                                           else
   11670                                             {
   11671                                               /* 33222222222211111111110000000000
   11672                                                  10987654321098765432109876543210
   11673                                                  110001x1xx1xxxxx001xxxxxxxxxxxxx
   11674                                                  ldff1sw.  */
   11675                                               return 1688;
   11676                                             }
   11677                                         }
   11678                                     }
   11679                                   else
   11680                                     {
   11681                                       if (((word >> 21) & 0x1) == 0)
   11682                                         {
   11683                                           if (((word >> 31) & 0x1) == 0)
   11684                                             {
   11685                                               if (((word >> 10) & 0x1) == 0)
   11686                                                 {
   11687                                                   if (((word >> 11) & 0x1) == 0)
   11688                                                     {
   11689                                                       if (((word >> 12) & 0x1) == 0)
   11690                                                         {
   11691                                                           /* 33222222222211111111110000000000
   11692                                                              10987654321098765432109876543210
   11693                                                              010001x1xx0xxxxx101000xxxxxxxxxx
   11694                                                              sshllb.  */
   11695                                                           return 2234;
   11696                                                         }
   11697                                                       else
   11698                                                         {
   11699                                                           /* 33222222222211111111110000000000
   11700                                                              10987654321098765432109876543210
   11701                                                              010001x1xx0xxxxx101100xxxxxxxxxx
   11702                                                              bext.  */
   11703                                                           return 2339;
   11704                                                         }
   11705                                                     }
   11706                                                   else
   11707                                                     {
   11708                                                       if (((word >> 12) & 0x1) == 0)
   11709                                                         {
   11710                                                           /* 33222222222211111111110000000000
   11711                                                              10987654321098765432109876543210
   11712                                                              010001x1xx0xxxxx101010xxxxxxxxxx
   11713                                                              ushllb.  */
   11714                                                           return 2310;
   11715                                                         }
   11716                                                       else
   11717                                                         {
   11718                                                           /* 33222222222211111111110000000000
   11719                                                              10987654321098765432109876543210
   11720                                                              010001x1xx0xxxxx101110xxxxxxxxxx
   11721                                                              bgrp.  */
   11722                                                           return 2340;
   11723                                                         }
   11724                                                     }
   11725                                                 }
   11726                                               else
   11727                                                 {
   11728                                                   if (((word >> 11) & 0x1) == 0)
   11729                                                     {
   11730                                                       if (((word >> 12) & 0x1) == 0)
   11731                                                         {
   11732                                                           /* 33222222222211111111110000000000
   11733                                                              10987654321098765432109876543210
   11734                                                              010001x1xx0xxxxx101001xxxxxxxxxx
   11735                                                              sshllt.  */
   11736                                                           return 2235;
   11737                                                         }
   11738                                                       else
   11739                                                         {
   11740                                                           /* 33222222222211111111110000000000
   11741                                                              10987654321098765432109876543210
   11742                                                              010001x1xx0xxxxx101101xxxxxxxxxx
   11743                                                              bdep.  */
   11744                                                           return 2338;
   11745                                                         }
   11746                                                     }
   11747                                                   else
   11748                                                     {
   11749                                                       /* 33222222222211111111110000000000
   11750                                                          10987654321098765432109876543210
   11751                                                          010001x1xx0xxxxx101x11xxxxxxxxxx
   11752                                                          ushllt.  */
   11753                                                       return 2311;
   11754                                                     }
   11755                                                 }
   11756                                             }
   11757                                           else
   11758                                             {
   11759                                               /* 33222222222211111111110000000000
   11760                                                  10987654321098765432109876543210
   11761                                                  110001x1xx0xxxxx101xxxxxxxxxxxxx
   11762                                                  ldff1sw.  */
   11763                                               return 1689;
   11764                                             }
   11765                                         }
   11766                                       else
   11767                                         {
   11768                                           if (((word >> 22) & 0x1) == 0)
   11769                                             {
   11770                                               if (((word >> 31) & 0x1) == 0)
   11771                                                 {
   11772                                                   /* 33222222222211111111110000000000
   11773                                                      10987654321098765432109876543210
   11774                                                      010001x1x01xxxxx101xxxxxxxxxxxxx
   11775                                                      histseg.  */
   11776                                                   return 2091;
   11777                                                 }
   11778                                               else
   11779                                                 {
   11780                                                   /* 33222222222211111111110000000000
   11781                                                      10987654321098765432109876543210
   11782                                                      110001x1x01xxxxx101xxxxxxxxxxxxx
   11783                                                      ldff1sw.  */
   11784                                                   return 1691;
   11785                                                 }
   11786                                             }
   11787                                           else
   11788                                             {
   11789                                               /* 33222222222211111111110000000000
   11790                                                  10987654321098765432109876543210
   11791                                                  x10001x1x11xxxxx101xxxxxxxxxxxxx
   11792                                                  ldff1sw.  */
   11793                                               return 1690;
   11794                                             }
   11795                                         }
   11796                                     }
   11797                                 }
   11798                               else
   11799                                 {
   11800                                   if (((word >> 15) & 0x1) == 0)
   11801                                     {
   11802                                       if (((word >> 21) & 0x1) == 0)
   11803                                         {
   11804                                           if (((word >> 31) & 0x1) == 0)
   11805                                             {
   11806                                               if (((word >> 10) & 0x1) == 0)
   11807                                                 {
   11808                                                   if (((word >> 11) & 0x1) == 0)
   11809                                                     {
   11810                                                       if (((word >> 12) & 0x1) == 0)
   11811                                                         {
   11812                                                           /* 33222222222211111111110000000000
   11813                                                              10987654321098765432109876543210
   11814                                                              010001x1xx0xxxxx011000xxxxxxxxxx
   11815                                                              sqdmullb.  */
   11816                                                           return 2188;
   11817                                                         }
   11818                                                       else
   11819                                                         {
   11820                                                           /* 33222222222211111111110000000000
   11821                                                              10987654321098765432109876543210
   11822                                                              010001x1xx0xxxxx011100xxxxxxxxxx
   11823                                                              smullb.  */
   11824                                                           return 2160;
   11825                                                         }
   11826                                                     }
   11827                                                   else
   11828                                                     {
   11829                                                       if (((word >> 12) & 0x1) == 0)
   11830                                                         {
   11831                                                           if (((word >> 22) & 0x1) == 0)
   11832                                                             {
   11833                                                               /* 33222222222211111111110000000000
   11834                                                                  10987654321098765432109876543210
   11835                                                                  010001x1x00xxxxx011010xxxxxxxxxx
   11836                                                                  pmullb.  */
   11837                                                               return 2335;
   11838                                                             }
   11839                                                           else
   11840                                                             {
   11841                                                               /* 33222222222211111111110000000000
   11842                                                                  10987654321098765432109876543210
   11843                                                                  010001x1x10xxxxx011010xxxxxxxxxx
   11844                                                                  pmullb.  */
   11845                                                               return 2116;
   11846                                                             }
   11847                                                         }
   11848                                                       else
   11849                                                         {
   11850                                                           /* 33222222222211111111110000000000
   11851                                                              10987654321098765432109876543210
   11852                                                              010001x1xx0xxxxx011110xxxxxxxxxx
   11853                                                              umullb.  */
   11854                                                           return 2285;
   11855                                                         }
   11856                                                     }
   11857                                                 }
   11858                                               else
   11859                                                 {
   11860                                                   if (((word >> 11) & 0x1) == 0)
   11861                                                     {
   11862                                                       if (((word >> 12) & 0x1) == 0)
   11863                                                         {
   11864                                                           /* 33222222222211111111110000000000
   11865                                                              10987654321098765432109876543210
   11866                                                              010001x1xx0xxxxx011001xxxxxxxxxx
   11867                                                              sqdmullt.  */
   11868                                                           return 2191;
   11869                                                         }
   11870                                                       else
   11871                                                         {
   11872                                                           /* 33222222222211111111110000000000
   11873                                                              10987654321098765432109876543210
   11874                                                              010001x1xx0xxxxx011101xxxxxxxxxx
   11875                                                              smullt.  */
   11876                                                           return 2163;
   11877                                                         }
   11878                                                     }
   11879                                                   else
   11880                                                     {
   11881                                                       if (((word >> 12) & 0x1) == 0)
   11882                                                         {
   11883                                                           if (((word >> 22) & 0x1) == 0)
   11884                                                             {
   11885                                                               /* 33222222222211111111110000000000
   11886                                                                  10987654321098765432109876543210
   11887                                                                  010001x1x00xxxxx011011xxxxxxxxxx
   11888                                                                  pmullt.  */
   11889                                                               return 2336;
   11890                                                             }
   11891                                                           else
   11892                                                             {
   11893                                                               /* 33222222222211111111110000000000
   11894                                                                  10987654321098765432109876543210
   11895                                                                  010001x1x10xxxxx011011xxxxxxxxxx
   11896                                                                  pmullt.  */
   11897                                                               return 2117;
   11898                                                             }
   11899                                                         }
   11900                                                       else
   11901                                                         {
   11902                                                           /* 33222222222211111111110000000000
   11903                                                              10987654321098765432109876543210
   11904                                                              010001x1xx0xxxxx011111xxxxxxxxxx
   11905                                                              umullt.  */
   11906                                                           return 2288;
   11907                                                         }
   11908                                                     }
   11909                                                 }
   11910                                             }
   11911                                           else
   11912                                             {
   11913                                               if (((word >> 23) & 0x1) == 0)
   11914                                                 {
   11915                                                   /* 33222222222211111111110000000000
   11916                                                      10987654321098765432109876543210
   11917                                                      110001x10x0xxxxx011xxxxxxxxxxxxx
   11918                                                      ldff1w.  */
   11919                                                   return 1698;
   11920                                                 }
   11921                                               else
   11922                                                 {
   11923                                                   /* 33222222222211111111110000000000
   11924                                                      10987654321098765432109876543210
   11925                                                      110001x11x0xxxxx011xxxxxxxxxxxxx
   11926                                                      ldff1d.  */
   11927                                                   return 1643;
   11928                                                 }
   11929                                             }
   11930                                         }
   11931                                       else
   11932                                         {
   11933                                           if (((word >> 31) & 0x1) == 0)
   11934                                             {
   11935                                               if (((word >> 10) & 0x1) == 0)
   11936                                                 {
   11937                                                   if (((word >> 11) & 0x1) == 0)
   11938                                                     {
   11939                                                       if (((word >> 12) & 0x1) == 0)
   11940                                                         {
   11941                                                           /* 33222222222211111111110000000000
   11942                                                              10987654321098765432109876543210
   11943                                                              010001x1xx1xxxxx011000xxxxxxxxxx
   11944                                                              addhnb.  */
   11945                                                           return 2052;
   11946                                                         }
   11947                                                       else
   11948                                                         {
   11949                                                           /* 33222222222211111111110000000000
   11950                                                              10987654321098765432109876543210
   11951                                                              010001x1xx1xxxxx011100xxxxxxxxxx
   11952                                                              subhnb.  */
   11953                                                           return 2250;
   11954                                                         }
   11955                                                     }
   11956                                                   else
   11957                                                     {
   11958                                                       if (((word >> 12) & 0x1) == 0)
   11959                                                         {
   11960                                                           /* 33222222222211111111110000000000
   11961                                                              10987654321098765432109876543210
   11962                                                              010001x1xx1xxxxx011010xxxxxxxxxx
   11963                                                              raddhnb.  */
   11964                                                           return 2118;
   11965                                                         }
   11966                                                       else
   11967                                                         {
   11968                                                           /* 33222222222211111111110000000000
   11969                                                              10987654321098765432109876543210
   11970                                                              010001x1xx1xxxxx011110xxxxxxxxxx
   11971                                                              rsubhnb.  */
   11972                                                           return 2122;
   11973                                                         }
   11974                                                     }
   11975                                                 }
   11976                                               else
   11977                                                 {
   11978                                                   if (((word >> 11) & 0x1) == 0)
   11979                                                     {
   11980                                                       if (((word >> 12) & 0x1) == 0)
   11981                                                         {
   11982                                                           /* 33222222222211111111110000000000
   11983                                                              10987654321098765432109876543210
   11984                                                              010001x1xx1xxxxx011001xxxxxxxxxx
   11985                                                              addhnt.  */
   11986                                                           return 2053;
   11987                                                         }
   11988                                                       else
   11989                                                         {
   11990                                                           /* 33222222222211111111110000000000
   11991                                                              10987654321098765432109876543210
   11992                                                              010001x1xx1xxxxx011101xxxxxxxxxx
   11993                                                              subhnt.  */
   11994                                                           return 2251;
   11995                                                         }
   11996                                                     }
   11997                                                   else
   11998                                                     {
   11999                                                       if (((word >> 12) & 0x1) == 0)
   12000                                                         {
   12001                                                           /* 33222222222211111111110000000000
   12002                                                              10987654321098765432109876543210
   12003                                                              010001x1xx1xxxxx011011xxxxxxxxxx
   12004                                                              raddhnt.  */
   12005                                                           return 2119;
   12006                                                         }
   12007                                                       else
   12008                                                         {
   12009                                                           /* 33222222222211111111110000000000
   12010                                                              10987654321098765432109876543210
   12011                                                              010001x1xx1xxxxx011111xxxxxxxxxx
   12012                                                              rsubhnt.  */
   12013                                                           return 2123;
   12014                                                         }
   12015                                                     }
   12016                                                 }
   12017                                             }
   12018                                           else
   12019                                             {
   12020                                               if (((word >> 23) & 0x1) == 0)
   12021                                                 {
   12022                                                   /* 33222222222211111111110000000000
   12023                                                      10987654321098765432109876543210
   12024                                                      110001x10x1xxxxx011xxxxxxxxxxxxx
   12025                                                      ldff1w.  */
   12026                                                   return 1699;
   12027                                                 }
   12028                                               else
   12029                                                 {
   12030                                                   /* 33222222222211111111110000000000
   12031                                                      10987654321098765432109876543210
   12032                                                      110001x11x1xxxxx011xxxxxxxxxxxxx
   12033                                                      ldff1d.  */
   12034                                                   return 1644;
   12035                                                 }
   12036                                             }
   12037                                         }
   12038                                     }
   12039                                   else
   12040                                     {
   12041                                       if (((word >> 21) & 0x1) == 0)
   12042                                         {
   12043                                           if (((word >> 31) & 0x1) == 0)
   12044                                             {
   12045                                               if (((word >> 10) & 0x1) == 0)
   12046                                                 {
   12047                                                   if (((word >> 11) & 0x1) == 0)
   12048                                                     {
   12049                                                       if (((word >> 12) & 0x1) == 0)
   12050                                                         {
   12051                                                           /* 33222222222211111111110000000000
   12052                                                              10987654321098765432109876543210
   12053                                                              010001x1xx0xxxxx111000xxxxxxxxxx
   12054                                                              ssra.  */
   12055                                                           return 2236;
   12056                                                         }
   12057                                                       else
   12058                                                         {
   12059                                                           /* 33222222222211111111110000000000
   12060                                                              10987654321098765432109876543210
   12061                                                              010001x1xx0xxxxx111100xxxxxxxxxx
   12062                                                              sri.  */
   12063                                                           return 2229;
   12064                                                         }
   12065                                                     }
   12066                                                   else
   12067                                                     {
   12068                                                       if (((word >> 12) & 0x1) == 0)
   12069                                                         {
   12070                                                           /* 33222222222211111111110000000000
   12071                                                              10987654321098765432109876543210
   12072                                                              010001x1xx0xxxxx111010xxxxxxxxxx
   12073                                                              srsra.  */
   12074                                                           return 2233;
   12075                                                         }
   12076                                                       else
   12077                                                         {
   12078                                                           /* 33222222222211111111110000000000
   12079                                                              10987654321098765432109876543210
   12080                                                              010001x1xx0xxxxx111110xxxxxxxxxx
   12081                                                              saba.  */
   12082                                                           return 2124;
   12083                                                         }
   12084                                                     }
   12085                                                 }
   12086                                               else
   12087                                                 {
   12088                                                   if (((word >> 11) & 0x1) == 0)
   12089                                                     {
   12090                                                       if (((word >> 12) & 0x1) == 0)
   12091                                                         {
   12092                                                           /* 33222222222211111111110000000000
   12093                                                              10987654321098765432109876543210
   12094                                                              010001x1xx0xxxxx111001xxxxxxxxxx
   12095                                                              usra.  */
   12096                                                           return 2313;
   12097                                                         }
   12098                                                       else
   12099                                                         {
   12100                                                           /* 33222222222211111111110000000000
   12101                                                              10987654321098765432109876543210
   12102                                                              010001x1xx0xxxxx111101xxxxxxxxxx
   12103                                                              sli.  */
   12104                                                           return 2142;
   12105                                                         }
   12106                                                     }
   12107                                                   else
   12108                                                     {
   12109                                                       if (((word >> 12) & 0x1) == 0)
   12110                                                         {
   12111                                                           /* 33222222222211111111110000000000
   12112                                                              10987654321098765432109876543210
   12113                                                              010001x1xx0xxxxx111011xxxxxxxxxx
   12114                                                              ursra.  */
   12115                                                           return 2309;
   12116                                                         }
   12117                                                       else
   12118                                                         {
   12119                                                           /* 33222222222211111111110000000000
   12120                                                              10987654321098765432109876543210
   12121                                                              010001x1xx0xxxxx111111xxxxxxxxxx
   12122                                                              uaba.  */
   12123                                                           return 2255;
   12124                                                         }
   12125                                                     }
   12126                                                 }
   12127                                             }
   12128                                           else
   12129                                             {
   12130                                               if (((word >> 22) & 0x1) == 0)
   12131                                                 {
   12132                                                   if (((word >> 23) & 0x1) == 0)
   12133                                                     {
   12134                                                       /* 33222222222211111111110000000000
   12135                                                          10987654321098765432109876543210
   12136                                                          110001x1000xxxxx111xxxxxxxxxxxxx
   12137                                                          prfw.  */
   12138                                                       return 1794;
   12139                                                     }
   12140                                                   else
   12141                                                     {
   12142                                                       /* 33222222222211111111110000000000
   12143                                                          10987654321098765432109876543210
   12144                                                          110001x1100xxxxx111xxxxxxxxxxxxx
   12145                                                          prfd.  */
   12146                                                       return 1780;
   12147                                                     }
   12148                                                 }
   12149                                               else
   12150                                                 {
   12151                                                   if (((word >> 23) & 0x1) == 0)
   12152                                                     {
   12153                                                       /* 33222222222211111111110000000000
   12154                                                          10987654321098765432109876543210
   12155                                                          110001x1010xxxxx111xxxxxxxxxxxxx
   12156                                                          ldff1w.  */
   12157                                                       return 1700;
   12158                                                     }
   12159                                                   else
   12160                                                     {
   12161                                                       /* 33222222222211111111110000000000
   12162                                                          10987654321098765432109876543210
   12163                                                          110001x1110xxxxx111xxxxxxxxxxxxx
   12164                                                          ldff1d.  */
   12165                                                       return 1645;
   12166                                                     }
   12167                                                 }
   12168                                             }
   12169                                         }
   12170                                       else
   12171                                         {
   12172                                           if (((word >> 22) & 0x1) == 0)
   12173                                             {
   12174                                               if (((word >> 23) & 0x1) == 0)
   12175                                                 {
   12176                                                   if (((word >> 31) & 0x1) == 0)
   12177                                                     {
   12178                                                       if (((word >> 10) & 0x1) == 0)
   12179                                                         {
   12180                                                           if (((word >> 12) & 0x1) == 0)
   12181                                                             {
   12182                                                               if (((word >> 16) & 0x1) == 0)
   12183                                                                 {
   12184                                                                   if (((word >> 17) & 0x1) == 0)
   12185                                                                     {
   12186                                                                       /* 33222222222211111111110000000000
   12187                                                                          10987654321098765432109876543210
   12188                                                                          010001x1001xxx001110x0xxxxxxxxxx
   12189                                                                          aesmc.  */
   12190                                                                       return 2334;
   12191                                                                     }
   12192                                                                   else
   12193                                                                     {
   12194                                                                       /* 33222222222211111111110000000000
   12195                                                                          10987654321098765432109876543210
   12196                                                                          010001x1001xxx101110x0xxxxxxxxxx
   12197                                                                          aese.  */
   12198                                                                       return 2332;
   12199                                                                     }
   12200                                                                 }
   12201                                                               else
   12202                                                                 {
   12203                                                                   /* 33222222222211111111110000000000
   12204                                                                      10987654321098765432109876543210
   12205                                                                      010001x1001xxxx11110x0xxxxxxxxxx
   12206                                                                      sm4e.  */
   12207                                                                   return 2329;
   12208                                                                 }
   12209                                                             }
   12210                                                           else
   12211                                                             {
   12212                                                               /* 33222222222211111111110000000000
   12213                                                                  10987654321098765432109876543210
   12214                                                                  010001x1001xxxxx1111x0xxxxxxxxxx
   12215                                                                  sm4ekey.  */
   12216                                                               return 2330;
   12217                                                             }
   12218                                                         }
   12219                                                       else
   12220                                                         {
   12221                                                           if (((word >> 12) & 0x1) == 0)
   12222                                                             {
   12223                                                               if (((word >> 17) & 0x1) == 0)
   12224                                                                 {
   12225                                                                   /* 33222222222211111111110000000000
   12226                                                                      10987654321098765432109876543210
   12227                                                                      010001x1001xxx0x1110x1xxxxxxxxxx
   12228                                                                      aesimc.  */
   12229                                                                   return 2333;
   12230                                                                 }
   12231                                                               else
   12232                                                                 {
   12233                                                                   /* 33222222222211111111110000000000
   12234                                                                      10987654321098765432109876543210
   12235                                                                      010001x1001xxx1x1110x1xxxxxxxxxx
   12236                                                                      aesd.  */
   12237                                                                   return 2331;
   12238                                                                 }
   12239                                                             }
   12240                                                           else
   12241                                                             {
   12242                                                               /* 33222222222211111111110000000000
   12243                                                                  10987654321098765432109876543210
   12244                                                                  010001x1001xxxxx1111x1xxxxxxxxxx
   12245                                                                  rax1.  */
   12246                                                               return 2337;
   12247                                                             }
   12248                                                         }
   12249                                                     }
   12250                                                   else
   12251                                                     {
   12252                                                       /* 33222222222211111111110000000000
   12253                                                          10987654321098765432109876543210
   12254                                                          110001x1001xxxxx111xxxxxxxxxxxxx
   12255                                                          ldff1w.  */
   12256                                                       return 1703;
   12257                                                     }
   12258                                                 }
   12259                                               else
   12260                                                 {
   12261                                                   /* 33222222222211111111110000000000
   12262                                                      10987654321098765432109876543210
   12263                                                      x10001x1101xxxxx111xxxxxxxxxxxxx
   12264                                                      ldff1d.  */
   12265                                                   return 1647;
   12266                                                 }
   12267                                             }
   12268                                           else
   12269                                             {
   12270                                               if (((word >> 23) & 0x1) == 0)
   12271                                                 {
   12272                                                   /* 33222222222211111111110000000000
   12273                                                      10987654321098765432109876543210
   12274                                                      x10001x1011xxxxx111xxxxxxxxxxxxx
   12275                                                      ldff1w.  */
   12276                                                   return 1701;
   12277                                                 }
   12278                                               else
   12279                                                 {
   12280                                                   /* 33222222222211111111110000000000
   12281                                                      10987654321098765432109876543210
   12282                                                      x10001x1111xxxxx111xxxxxxxxxxxxx
   12283                                                      ldff1d.  */
   12284                                                   return 1646;
   12285                                                 }
   12286                                             }
   12287                                         }
   12288                                     }
   12289                                 }
   12290                             }
   12291                         }
   12292                     }
   12293                   else
   12294                     {
   12295                       if (((word >> 15) & 0x1) == 0)
   12296                         {
   12297                           if (((word >> 14) & 0x1) == 0)
   12298                             {
   12299                               if (((word >> 13) & 0x1) == 0)
   12300                                 {
   12301                                   if (((word >> 30) & 0x1) == 0)
   12302                                     {
   12303                                       if (((word >> 21) & 0x1) == 0)
   12304                                         {
   12305                                           if (((word >> 31) & 0x1) == 0)
   12306                                             {
   12307                                               if (((word >> 4) & 0x1) == 0)
   12308                                                 {
   12309                                                   /* 33222222222211111111110000000000
   12310                                                      10987654321098765432109876543210
   12311                                                      001001x1xx0xxxxx000xxxxxxxx0xxxx
   12312                                                      cmpge.  */
   12313                                                   return 1326;
   12314                                                 }
   12315                                               else
   12316                                                 {
   12317                                                   /* 33222222222211111111110000000000
   12318                                                      10987654321098765432109876543210
   12319                                                      001001x1xx0xxxxx000xxxxxxxx1xxxx
   12320                                                      cmpgt.  */
   12321                                                   return 1329;
   12322                                                 }
   12323                                             }
   12324                                           else
   12325                                             {
   12326                                               if (((word >> 23) & 0x1) == 0)
   12327                                                 {
   12328                                                   /* 33222222222211111111110000000000
   12329                                                      10987654321098765432109876543210
   12330                                                      101001x10x0xxxxx000xxxxxxxxxxxxx
   12331                                                      ld1rqw.  */
   12332                                                   return 1553;
   12333                                                 }
   12334                                               else
   12335                                                 {
   12336                                                   /* 33222222222211111111110000000000
   12337                                                      10987654321098765432109876543210
   12338                                                      101001x11x0xxxxx000xxxxxxxxxxxxx
   12339                                                      ld1rqd.  */
   12340                                                   return 1549;
   12341                                                 }
   12342                                             }
   12343                                         }
   12344                                       else
   12345                                         {
   12346                                           if (((word >> 31) & 0x1) == 0)
   12347                                             {
   12348                                               if (((word >> 4) & 0x1) == 0)
   12349                                                 {
   12350                                                   if (((word >> 10) & 0x1) == 0)
   12351                                                     {
   12352                                                       if (((word >> 11) & 0x1) == 0)
   12353                                                         {
   12354                                                           if (((word >> 12) & 0x1) == 0)
   12355                                                             {
   12356                                                               /* 33222222222211111111110000000000
   12357                                                                  10987654321098765432109876543210
   12358                                                                  001001x1xx1xxxxx000000xxxxx0xxxx
   12359                                                                  whilege.  */
   12360                                                               return 2318;
   12361                                                             }
   12362                                                           else
   12363                                                             {
   12364                                                               /* 33222222222211111111110000000000
   12365                                                                  10987654321098765432109876543210
   12366                                                                  001001x1xx1xxxxx000100xxxxx0xxxx
   12367                                                                  whilege.  */
   12368                                                               return 2319;
   12369                                                             }
   12370                                                         }
   12371                                                       else
   12372                                                         {
   12373                                                           if (((word >> 12) & 0x1) == 0)
   12374                                                             {
   12375                                                               /* 33222222222211111111110000000000
   12376                                                                  10987654321098765432109876543210
   12377                                                                  001001x1xx1xxxxx000010xxxxx0xxxx
   12378                                                                  whilehs.  */
   12379                                                               return 2324;
   12380                                                             }
   12381                                                           else
   12382                                                             {
   12383                                                               /* 33222222222211111111110000000000
   12384                                                                  10987654321098765432109876543210
   12385                                                                  001001x1xx1xxxxx000110xxxxx0xxxx
   12386                                                                  whilehs.  */
   12387                                                               return 2325;
   12388                                                             }
   12389                                                         }
   12390                                                     }
   12391                                                   else
   12392                                                     {
   12393                                                       if (((word >> 11) & 0x1) == 0)
   12394                                                         {
   12395                                                           if (((word >> 12) & 0x1) == 0)
   12396                                                             {
   12397                                                               /* 33222222222211111111110000000000
   12398                                                                  10987654321098765432109876543210
   12399                                                                  001001x1xx1xxxxx000001xxxxx0xxxx
   12400                                                                  whilelt.  */
   12401                                                               return 2030;
   12402                                                             }
   12403                                                           else
   12404                                                             {
   12405                                                               /* 33222222222211111111110000000000
   12406                                                                  10987654321098765432109876543210
   12407                                                                  001001x1xx1xxxxx000101xxxxx0xxxx
   12408                                                                  whilelt.  */
   12409                                                               return 2031;
   12410                                                             }
   12411                                                         }
   12412                                                       else
   12413                                                         {
   12414                                                           if (((word >> 12) & 0x1) == 0)
   12415                                                             {
   12416                                                               /* 33222222222211111111110000000000
   12417                                                                  10987654321098765432109876543210
   12418                                                                  001001x1xx1xxxxx000011xxxxx0xxxx
   12419                                                                  whilelo.  */
   12420                                                               return 2026;
   12421                                                             }
   12422                                                           else
   12423                                                             {
   12424                                                               /* 33222222222211111111110000000000
   12425                                                                  10987654321098765432109876543210
   12426                                                                  001001x1xx1xxxxx000111xxxxx0xxxx
   12427                                                                  whilelo.  */
   12428                                                               return 2027;
   12429                                                             }
   12430                                                         }
   12431                                                     }
   12432                                                 }
   12433                                               else
   12434                                                 {
   12435                                                   if (((word >> 10) & 0x1) == 0)
   12436                                                     {
   12437                                                       if (((word >> 11) & 0x1) == 0)
   12438                                                         {
   12439                                                           if (((word >> 12) & 0x1) == 0)
   12440                                                             {
   12441                                                               /* 33222222222211111111110000000000
   12442                                                                  10987654321098765432109876543210
   12443                                                                  001001x1xx1xxxxx000000xxxxx1xxxx
   12444                                                                  whilegt.  */
   12445                                                               return 2320;
   12446                                                             }
   12447                                                           else
   12448                                                             {
   12449                                                               /* 33222222222211111111110000000000
   12450                                                                  10987654321098765432109876543210
   12451                                                                  001001x1xx1xxxxx000100xxxxx1xxxx
   12452                                                                  whilegt.  */
   12453                                                               return 2321;
   12454                                                             }
   12455                                                         }
   12456                                                       else
   12457                                                         {
   12458                                                           if (((word >> 12) & 0x1) == 0)
   12459                                                             {
   12460                                                               /* 33222222222211111111110000000000
   12461                                                                  10987654321098765432109876543210
   12462                                                                  001001x1xx1xxxxx000010xxxxx1xxxx
   12463                                                                  whilehi.  */
   12464                                                               return 2322;
   12465                                                             }
   12466                                                           else
   12467                                                             {
   12468                                                               /* 33222222222211111111110000000000
   12469                                                                  10987654321098765432109876543210
   12470                                                                  001001x1xx1xxxxx000110xxxxx1xxxx
   12471                                                                  whilehi.  */
   12472                                                               return 2323;
   12473                                                             }
   12474                                                         }
   12475                                                     }
   12476                                                   else
   12477                                                     {
   12478                                                       if (((word >> 11) & 0x1) == 0)
   12479                                                         {
   12480                                                           if (((word >> 12) & 0x1) == 0)
   12481                                                             {
   12482                                                               /* 33222222222211111111110000000000
   12483                                                                  10987654321098765432109876543210
   12484                                                                  001001x1xx1xxxxx000001xxxxx1xxxx
   12485                                                                  whilele.  */
   12486                                                               return 2024;
   12487                                                             }
   12488                                                           else
   12489                                                             {
   12490                                                               /* 33222222222211111111110000000000
   12491                                                                  10987654321098765432109876543210
   12492                                                                  001001x1xx1xxxxx000101xxxxx1xxxx
   12493                                                                  whilele.  */
   12494                                                               return 2025;
   12495                                                             }
   12496                                                         }
   12497                                                       else
   12498                                                         {
   12499                                                           if (((word >> 12) & 0x1) == 0)
   12500                                                             {
   12501                                                               /* 33222222222211111111110000000000
   12502                                                                  10987654321098765432109876543210
   12503                                                                  001001x1xx1xxxxx000011xxxxx1xxxx
   12504                                                                  whilels.  */
   12505                                                               return 2028;
   12506                                                             }
   12507                                                           else
   12508                                                             {
   12509                                                               /* 33222222222211111111110000000000
   12510                                                                  10987654321098765432109876543210
   12511                                                                  001001x1xx1xxxxx000111xxxxx1xxxx
   12512                                                                  whilels.  */
   12513                                                               return 2029;
   12514                                                             }
   12515                                                         }
   12516                                                     }
   12517                                                 }
   12518                                             }
   12519                                           else
   12520                                             {
   12521                                               if (((word >> 23) & 0x1) == 0)
   12522                                                 {
   12523                                                   /* 33222222222211111111110000000000
   12524                                                      10987654321098765432109876543210
   12525                                                      101001x10x1xxxxx000xxxxxxxxxxxxx
   12526                                                      ld1row.  */
   12527                                                   return 2404;
   12528                                                 }
   12529                                               else
   12530                                                 {
   12531                                                   /* 33222222222211111111110000000000
   12532                                                      10987654321098765432109876543210
   12533                                                      101001x11x1xxxxx000xxxxxxxxxxxxx
   12534                                                      ld1rod.  */
   12535                                                   return 2405;
   12536                                                 }
   12537                                             }
   12538                                         }
   12539                                     }
   12540                                   else
   12541                                     {
   12542                                       if (((word >> 31) & 0x1) == 0)
   12543                                         {
   12544                                           if (((word >> 21) & 0x1) == 0)
   12545                                             {
   12546                                               if (((word >> 10) & 0x1) == 0)
   12547                                                 {
   12548                                                   if (((word >> 11) & 0x1) == 0)
   12549                                                     {
   12550                                                       /* 33222222222211111111110000000000
   12551                                                          10987654321098765432109876543210
   12552                                                          011001x1xx0xxxxx000x00xxxxxxxxxx
   12553                                                          fadd.  */
   12554                                                       return 1384;
   12555                                                     }
   12556                                                   else
   12557                                                     {
   12558                                                       if (((word >> 12) & 0x1) == 0)
   12559                                                         {
   12560                                                           /* 33222222222211111111110000000000
   12561                                                              10987654321098765432109876543210
   12562                                                              011001x1xx0xxxxx000010xxxxxxxxxx
   12563                                                              fmul.  */
   12564                                                           return 1451;
   12565                                                         }
   12566                                                       else
   12567                                                         {
   12568                                                           /* 33222222222211111111110000000000
   12569                                                              10987654321098765432109876543210
   12570                                                              011001x1xx0xxxxx000110xxxxxxxxxx
   12571                                                              frecps.  */
   12572                                                           return 1464;
   12573                                                         }
   12574                                                     }
   12575                                                 }
   12576                                               else
   12577                                                 {
   12578                                                   if (((word >> 11) & 0x1) == 0)
   12579                                                     {
   12580                                                       /* 33222222222211111111110000000000
   12581                                                          10987654321098765432109876543210
   12582                                                          011001x1xx0xxxxx000x01xxxxxxxxxx
   12583                                                          fsub.  */
   12584                                                       return 1477;
   12585                                                     }
   12586                                                   else
   12587                                                     {
   12588                                                       if (((word >> 12) & 0x1) == 0)
   12589                                                         {
   12590                                                           /* 33222222222211111111110000000000
   12591                                                              10987654321098765432109876543210
   12592                                                              011001x1xx0xxxxx000011xxxxxxxxxx
   12593                                                              ftsmul.  */
   12594                                                           return 1483;
   12595                                                         }
   12596                                                       else
   12597                                                         {
   12598                                                           /* 33222222222211111111110000000000
   12599                                                              10987654321098765432109876543210
   12600                                                              011001x1xx0xxxxx000111xxxxxxxxxx
   12601                                                              frsqrts.  */
   12602                                                           return 1474;
   12603                                                         }
   12604                                                     }
   12605                                                 }
   12606                                             }
   12607                                           else
   12608                                             {
   12609                                               /* 33222222222211111111110000000000
   12610                                                  10987654321098765432109876543210
   12611                                                  011001x1xx1xxxxx000xxxxxxxxxxxxx
   12612                                                  fmla.  */
   12613                                               return 1442;
   12614                                             }
   12615                                         }
   12616                                       else
   12617                                         {
   12618                                           /* 33222222222211111111110000000000
   12619                                              10987654321098765432109876543210
   12620                                              111001x1xxxxxxxx000xxxxxxxxxxxxx
   12621                                              str.  */
   12622                                           return 1945;
   12623                                         }
   12624                                     }
   12625                                 }
   12626                               else
   12627                                 {
   12628                                   if (((word >> 21) & 0x1) == 0)
   12629                                     {
   12630                                       if (((word >> 30) & 0x1) == 0)
   12631                                         {
   12632                                           if (((word >> 31) & 0x1) == 0)
   12633                                             {
   12634                                               if (((word >> 4) & 0x1) == 0)
   12635                                                 {
   12636                                                   /* 33222222222211111111110000000000
   12637                                                      10987654321098765432109876543210
   12638                                                      001001x1xx0xxxxx001xxxxxxxx0xxxx
   12639                                                      cmplt.  */
   12640                                                   return 1343;
   12641                                                 }
   12642                                               else
   12643                                                 {
   12644                                                   /* 33222222222211111111110000000000
   12645                                                      10987654321098765432109876543210
   12646                                                      001001x1xx0xxxxx001xxxxxxxx1xxxx
   12647                                                      cmple.  */
   12648                                                   return 1337;
   12649                                                 }
   12650                                             }
   12651                                           else
   12652                                             {
   12653                                               if (((word >> 23) & 0x1) == 0)
   12654                                                 {
   12655                                                   /* 33222222222211111111110000000000
   12656                                                      10987654321098765432109876543210
   12657                                                      101001x10x0xxxxx001xxxxxxxxxxxxx
   12658                                                      ld1rqw.  */
   12659                                                   return 1552;
   12660                                                 }
   12661                                               else
   12662                                                 {
   12663                                                   /* 33222222222211111111110000000000
   12664                                                      10987654321098765432109876543210
   12665                                                      101001x11x0xxxxx001xxxxxxxxxxxxx
   12666                                                      ld1rqd.  */
   12667                                                   return 1548;
   12668                                                 }
   12669                                             }
   12670                                         }
   12671                                       else
   12672                                         {
   12673                                           if (((word >> 31) & 0x1) == 0)
   12674                                             {
   12675                                               if (((word >> 16) & 0x1) == 0)
   12676                                                 {
   12677                                                   if (((word >> 17) & 0x1) == 0)
   12678                                                     {
   12679                                                       if (((word >> 18) & 0x1) == 0)
   12680                                                         {
   12681                                                           if (((word >> 19) & 0x1) == 0)
   12682                                                             {
   12683                                                               if (((word >> 20) & 0x1) == 0)
   12684                                                                 {
   12685                                                                   /* 33222222222211111111110000000000
   12686                                                                      10987654321098765432109876543210
   12687                                                                      011001x1xx000000001xxxxxxxxxxxxx
   12688                                                                      faddv.  */
   12689                                                                   return 1388;
   12690                                                                 }
   12691                                                               else
   12692                                                                 {
   12693                                                                   if (((word >> 4) & 0x1) == 0)
   12694                                                                     {
   12695                                                                       /* 33222222222211111111110000000000
   12696                                                                          10987654321098765432109876543210
   12697                                                                          011001x1xx010000001xxxxxxxx0xxxx
   12698                                                                          fcmge.  */
   12699                                                                       return 1395;
   12700                                                                     }
   12701                                                                   else
   12702                                                                     {
   12703                                                                       /* 33222222222211111111110000000000
   12704                                                                          10987654321098765432109876543210
   12705                                                                          011001x1xx010000001xxxxxxxx1xxxx
   12706                                                                          fcmgt.  */
   12707                                                                       return 1397;
   12708                                                                     }
   12709                                                                 }
   12710                                                             }
   12711                                                           else
   12712                                                             {
   12713                                                               /* 33222222222211111111110000000000
   12714                                                                  10987654321098765432109876543210
   12715                                                                  011001x1xx0x1000001xxxxxxxxxxxxx
   12716                                                                  fadda.  */
   12717                                                               return 1387;
   12718                                                             }
   12719                                                         }
   12720                                                       else
   12721                                                         {
   12722                                                           /* 33222222222211111111110000000000
   12723                                                              10987654321098765432109876543210
   12724                                                              011001x1xx0xx100001xxxxxxxxxxxxx
   12725                                                              fmaxnmv.  */
   12726                                                           return 1434;
   12727                                                         }
   12728                                                     }
   12729                                                   else
   12730                                                     {
   12731                                                       if (((word >> 18) & 0x1) == 0)
   12732                                                         {
   12733                                                           /* 33222222222211111111110000000000
   12734                                                              10987654321098765432109876543210
   12735                                                              011001x1xx0xx010001xxxxxxxxxxxxx
   12736                                                              fcmeq.  */
   12737                                                           return 1393;
   12738                                                         }
   12739                                                       else
   12740                                                         {
   12741                                                           if (((word >> 19) & 0x1) == 0)
   12742                                                             {
   12743                                                               /* 33222222222211111111110000000000
   12744                                                                  10987654321098765432109876543210
   12745                                                                  011001x1xx0x0110001xxxxxxxxxxxxx
   12746                                                                  fmaxv.  */
   12747                                                               return 1435;
   12748                                                             }
   12749                                                           else
   12750                                                             {
   12751                                                               /* 33222222222211111111110000000000
   12752                                                                  10987654321098765432109876543210
   12753                                                                  011001x1xx0x1110001xxxxxxxxxxxxx
   12754                                                                  frecpe.  */
   12755                                                               return 1463;
   12756                                                             }
   12757                                                         }
   12758                                                     }
   12759                                                 }
   12760                                               else
   12761                                                 {
   12762                                                   if (((word >> 17) & 0x1) == 0)
   12763                                                     {
   12764                                                       if (((word >> 18) & 0x1) == 0)
   12765                                                         {
   12766                                                           if (((word >> 4) & 0x1) == 0)
   12767                                                             {
   12768                                                               /* 33222222222211111111110000000000
   12769                                                                  10987654321098765432109876543210
   12770                                                                  011001x1xx0xx001001xxxxxxxx0xxxx
   12771                                                                  fcmlt.  */
   12772                                                               return 1400;
   12773                                                             }
   12774                                                           else
   12775                                                             {
   12776                                                               /* 33222222222211111111110000000000
   12777                                                                  10987654321098765432109876543210
   12778                                                                  011001x1xx0xx001001xxxxxxxx1xxxx
   12779                                                                  fcmle.  */
   12780                                                               return 1399;
   12781                                                             }
   12782                                                         }
   12783                                                       else
   12784                                                         {
   12785                                                           /* 33222222222211111111110000000000
   12786                                                              10987654321098765432109876543210
   12787                                                              011001x1xx0xx101001xxxxxxxxxxxxx
   12788                                                              fminnmv.  */
   12789                                                           return 1440;
   12790                                                         }
   12791                                                     }
   12792                                                   else
   12793                                                     {
   12794                                                       if (((word >> 18) & 0x1) == 0)
   12795                                                         {
   12796                                                           /* 33222222222211111111110000000000
   12797                                                              10987654321098765432109876543210
   12798                                                              011001x1xx0xx011001xxxxxxxxxxxxx
   12799                                                              fcmne.  */
   12800                                                           return 1401;
   12801                                                         }
   12802                                                       else
   12803                                                         {
   12804                                                           if (((word >> 19) & 0x1) == 0)
   12805                                                             {
   12806                                                               /* 33222222222211111111110000000000
   12807                                                                  10987654321098765432109876543210
   12808                                                                  011001x1xx0x0111001xxxxxxxxxxxxx
   12809                                                                  fminv.  */
   12810                                                               return 1441;
   12811                                                             }
   12812                                                           else
   12813                                                             {
   12814                                                               /* 33222222222211111111110000000000
   12815                                                                  10987654321098765432109876543210
   12816                                                                  011001x1xx0x1111001xxxxxxxxxxxxx
   12817                                                                  frsqrte.  */
   12818                                                               return 1473;
   12819                                                             }
   12820                                                         }
   12821                                                     }
   12822                                                 }
   12823                                             }
   12824                                           else
   12825                                             {
   12826                                               if (((word >> 22) & 0x1) == 0)
   12827                                                 {
   12828                                                   if (((word >> 23) & 0x1) == 0)
   12829                                                     {
   12830                                                       /* 33222222222211111111110000000000
   12831                                                          10987654321098765432109876543210
   12832                                                          111001x1000xxxxx001xxxxxxxxxxxxx
   12833                                                          stnt1w.  */
   12834                                                       return 2249;
   12835                                                     }
   12836                                                   else
   12837                                                     {
   12838                                                       /* 33222222222211111111110000000000
   12839                                                          10987654321098765432109876543210
   12840                                                          111001x1100xxxxx001xxxxxxxxxxxxx
   12841                                                          stnt1d.  */
   12842                                                       return 2245;
   12843                                                     }
   12844                                                 }
   12845                                               else
   12846                                                 {
   12847                                                   /* 33222222222211111111110000000000
   12848                                                      10987654321098765432109876543210
   12849                                                      111001x1x10xxxxx001xxxxxxxxxxxxx
   12850                                                      stnt1w.  */
   12851                                                   return 2248;
   12852                                                 }
   12853                                             }
   12854                                         }
   12855                                     }
   12856                                   else
   12857                                     {
   12858                                       if (((word >> 30) & 0x1) == 0)
   12859                                         {
   12860                                           if (((word >> 31) & 0x1) == 0)
   12861                                             {
   12862                                               if (((word >> 4) & 0x1) == 0)
   12863                                                 {
   12864                                                   if (((word >> 12) & 0x1) == 0)
   12865                                                     {
   12866                                                       /* 33222222222211111111110000000000
   12867                                                          10987654321098765432109876543210
   12868                                                          001001x1xx1xxxxx0010xxxxxxx0xxxx
   12869                                                          ctermeq.  */
   12870                                                       return 1358;
   12871                                                     }
   12872                                                   else
   12873                                                     {
   12874                                                       /* 33222222222211111111110000000000
   12875                                                          10987654321098765432109876543210
   12876                                                          001001x1xx1xxxxx0011xxxxxxx0xxxx
   12877                                                          whilewr.  */
   12878                                                       return 2327;
   12879                                                     }
   12880                                                 }
   12881                                               else
   12882                                                 {
   12883                                                   if (((word >> 12) & 0x1) == 0)
   12884                                                     {
   12885                                                       /* 33222222222211111111110000000000
   12886                                                          10987654321098765432109876543210
   12887                                                          001001x1xx1xxxxx0010xxxxxxx1xxxx
   12888                                                          ctermne.  */
   12889                                                       return 1359;
   12890                                                     }
   12891                                                   else
   12892                                                     {
   12893                                                       /* 33222222222211111111110000000000
   12894                                                          10987654321098765432109876543210
   12895                                                          001001x1xx1xxxxx0011xxxxxxx1xxxx
   12896                                                          whilerw.  */
   12897                                                       return 2326;
   12898                                                     }
   12899                                                 }
   12900                                             }
   12901                                           else
   12902                                             {
   12903                                               if (((word >> 23) & 0x1) == 0)
   12904                                                 {
   12905                                                   /* 33222222222211111111110000000000
   12906                                                      10987654321098765432109876543210
   12907                                                      101001x10x1xxxxx001xxxxxxxxxxxxx
   12908                                                      ld1row.  */
   12909                                                   return 2408;
   12910                                                 }
   12911                                               else
   12912                                                 {
   12913                                                   /* 33222222222211111111110000000000
   12914                                                      10987654321098765432109876543210
   12915                                                      101001x11x1xxxxx001xxxxxxxxxxxxx
   12916                                                      ld1rod.  */
   12917                                                   return 2409;
   12918                                                 }
   12919                                             }
   12920                                         }
   12921                                       else
   12922                                         {
   12923                                           /* 33222222222211111111110000000000
   12924                                              10987654321098765432109876543210
   12925                                              x11001x1xx1xxxxx001xxxxxxxxxxxxx
   12926                                              fmls.  */
   12927                                           return 1446;
   12928                                         }
   12929                                     }
   12930                                 }
   12931                             }
   12932                           else
   12933                             {
   12934                               if (((word >> 30) & 0x1) == 0)
   12935                                 {
   12936                                   if (((word >> 21) & 0x1) == 0)
   12937                                     {
   12938                                       if (((word >> 22) & 0x1) == 0)
   12939                                         {
   12940                                           if (((word >> 23) & 0x1) == 0)
   12941                                             {
   12942                                               if (((word >> 31) & 0x1) == 0)
   12943                                                 {
   12944                                                   if (((word >> 9) & 0x1) == 0)
   12945                                                     {
   12946                                                       if (((word >> 20) & 0x1) == 0)
   12947                                                         {
   12948                                                           if (((word >> 4) & 0x1) == 0)
   12949                                                             {
   12950                                                               /* 33222222222211111111110000000000
   12951                                                                  10987654321098765432109876543210
   12952                                                                  001001x10000xxxx01xxxx0xxxx0xxxx
   12953                                                                  and.  */
   12954                                                               return 1289;
   12955                                                             }
   12956                                                           else
   12957                                                             {
   12958                                                               /* 33222222222211111111110000000000
   12959                                                                  10987654321098765432109876543210
   12960                                                                  001001x10000xxxx01xxxx0xxxx1xxxx
   12961                                                                  bic.  */
   12962                                                               return 1301;
   12963                                                             }
   12964                                                         }
   12965                                                       else
   12966                                                         {
   12967                                                           if (((word >> 19) & 0x1) == 0)
   12968                                                             {
   12969                                                               /* 33222222222211111111110000000000
   12970                                                                  10987654321098765432109876543210
   12971                                                                  001001x100010xxx01xxxx0xxxxxxxxx
   12972                                                                  brka.  */
   12973                                                               return 1303;
   12974                                                             }
   12975                                                           else
   12976                                                             {
   12977                                                               /* 33222222222211111111110000000000
   12978                                                                  10987654321098765432109876543210
   12979                                                                  001001x100011xxx01xxxx0xxxxxxxxx
   12980                                                                  brkn.  */
   12981                                                               return 1307;
   12982                                                             }
   12983                                                         }
   12984                                                     }
   12985                                                   else
   12986                                                     {
   12987                                                       if (((word >> 4) & 0x1) == 0)
   12988                                                         {
   12989                                                           /* 33222222222211111111110000000000
   12990                                                              10987654321098765432109876543210
   12991                                                              001001x1000xxxxx01xxxx1xxxx0xxxx
   12992                                                              eor.  */
   12993                                                           return 1376;
   12994                                                         }
   12995                                                       else
   12996                                                         {
   12997                                                           /* 33222222222211111111110000000000
   12998                                                              10987654321098765432109876543210
   12999                                                              001001x1000xxxxx01xxxx1xxxx1xxxx
   13000                                                              sel.  */
   13001                                                           return 1825;
   13002                                                         }
   13003                                                     }
   13004                                                 }
   13005                                               else
   13006                                                 {
   13007                                                   if (((word >> 13) & 0x1) == 0)
   13008                                                     {
   13009                                                       /* 33222222222211111111110000000000
   13010                                                          10987654321098765432109876543210
   13011                                                          101001x1000xxxxx010xxxxxxxxxxxxx
   13012                                                          ld1sh.  */
   13013                                                       return 1575;
   13014                                                     }
   13015                                                   else
   13016                                                     {
   13017                                                       /* 33222222222211111111110000000000
   13018                                                          10987654321098765432109876543210
   13019                                                          101001x1000xxxxx011xxxxxxxxxxxxx
   13020                                                          ldff1sh.  */
   13021                                                       return 1675;
   13022                                                     }
   13023                                                 }
   13024                                             }
   13025                                           else
   13026                                             {
   13027                                               if (((word >> 31) & 0x1) == 0)
   13028                                                 {
   13029                                                   if (((word >> 9) & 0x1) == 0)
   13030                                                     {
   13031                                                       if (((word >> 20) & 0x1) == 0)
   13032                                                         {
   13033                                                           if (((word >> 4) & 0x1) == 0)
   13034                                                             {
   13035                                                               /* 33222222222211111111110000000000
   13036                                                                  10987654321098765432109876543210
   13037                                                                  001001x11000xxxx01xxxx0xxxx0xxxx
   13038                                                                  orr.  */
   13039                                                               return 1761;
   13040                                                             }
   13041                                                           else
   13042                                                             {
   13043                                                               /* 33222222222211111111110000000000
   13044                                                                  10987654321098765432109876543210
   13045                                                                  001001x11000xxxx01xxxx0xxxx1xxxx
   13046                                                                  orn.  */
   13047                                                               return 1756;
   13048                                                             }
   13049                                                         }
   13050                                                       else
   13051                                                         {
   13052                                                           /* 33222222222211111111110000000000
   13053                                                              10987654321098765432109876543210
   13054                                                              001001x11001xxxx01xxxx0xxxxxxxxx
   13055                                                              brkb.  */
   13056                                                           return 1305;
   13057                                                         }
   13058                                                     }
   13059                                                   else
   13060                                                     {
   13061                                                       if (((word >> 4) & 0x1) == 0)
   13062                                                         {
   13063                                                           /* 33222222222211111111110000000000
   13064                                                              10987654321098765432109876543210
   13065                                                              001001x1100xxxxx01xxxx1xxxx0xxxx
   13066                                                              nor.  */
   13067                                                           return 1753;
   13068                                                         }
   13069                                                       else
   13070                                                         {
   13071                                                           /* 33222222222211111111110000000000
   13072                                                              10987654321098765432109876543210
   13073                                                              001001x1100xxxxx01xxxx1xxxx1xxxx
   13074                                                              nand.  */
   13075                                                           return 1750;
   13076                                                         }
   13077                                                     }
   13078                                                 }
   13079                                               else
   13080                                                 {
   13081                                                   if (((word >> 13) & 0x1) == 0)
   13082                                                     {
   13083                                                       /* 33222222222211111111110000000000
   13084                                                          10987654321098765432109876543210
   13085                                                          101001x1100xxxxx010xxxxxxxxxxxxx
   13086                                                          ld1sb.  */
   13087                                                       return 1563;
   13088                                                     }
   13089                                                   else
   13090                                                     {
   13091                                                       /* 33222222222211111111110000000000
   13092                                                          10987654321098765432109876543210
   13093                                                          101001x1100xxxxx011xxxxxxxxxxxxx
   13094                                                          ldff1sb.  */
   13095                                                       return 1663;
   13096                                                     }
   13097                                                 }
   13098                                             }
   13099                                         }
   13100                                       else
   13101                                         {
   13102                                           if (((word >> 23) & 0x1) == 0)
   13103                                             {
   13104                                               if (((word >> 31) & 0x1) == 0)
   13105                                                 {
   13106                                                   if (((word >> 4) & 0x1) == 0)
   13107                                                     {
   13108                                                       if (((word >> 9) & 0x1) == 0)
   13109                                                         {
   13110                                                           if (((word >> 20) & 0x1) == 0)
   13111                                                             {
   13112                                                               /* 33222222222211111111110000000000
   13113                                                                  10987654321098765432109876543210
   13114                                                                  001001x10100xxxx01xxxx0xxxx0xxxx
   13115                                                                  ands.  */
   13116                                                               return 1290;
   13117                                                             }
   13118                                                           else
   13119                                                             {
   13120                                                               if (((word >> 19) & 0x1) == 0)
   13121                                                                 {
   13122                                                                   /* 33222222222211111111110000000000
   13123                                                                      10987654321098765432109876543210
   13124                                                                      001001x101010xxx01xxxx0xxxx0xxxx
   13125                                                                      brkas.  */
   13126                                                                   return 1304;
   13127                                                                 }
   13128                                                               else
   13129                                                                 {
   13130                                                                   /* 33222222222211111111110000000000
   13131                                                                      10987654321098765432109876543210
   13132                                                                      001001x101011xxx01xxxx0xxxx0xxxx
   13133                                                                      brkns.  */
   13134                                                                   return 1308;
   13135                                                                 }
   13136                                                             }
   13137                                                         }
   13138                                                       else
   13139                                                         {
   13140                                                           /* 33222222222211111111110000000000
   13141                                                              10987654321098765432109876543210
   13142                                                              001001x1010xxxxx01xxxx1xxxx0xxxx
   13143                                                              eors.  */
   13144                                                           return 1377;
   13145                                                         }
   13146                                                     }
   13147                                                   else
   13148                                                     {
   13149                                                       /* 33222222222211111111110000000000
   13150                                                          10987654321098765432109876543210
   13151                                                          001001x1010xxxxx01xxxxxxxxx1xxxx
   13152                                                          bics.  */
   13153                                                       return 1302;
   13154                                                     }
   13155                                                 }
   13156                                               else
   13157                                                 {
   13158                                                   if (((word >> 13) & 0x1) == 0)
   13159                                                     {
   13160                                                       /* 33222222222211111111110000000000
   13161                                                          10987654321098765432109876543210
   13162                                                          101001x1010xxxxx010xxxxxxxxxxxxx
   13163                                                          ld1w.  */
   13164                                                       return 1594;
   13165                                                     }
   13166                                                   else
   13167                                                     {
   13168                                                       /* 33222222222211111111110000000000
   13169                                                          10987654321098765432109876543210
   13170                                                          101001x1010xxxxx011xxxxxxxxxxxxx
   13171                                                          ldff1w.  */
   13172                                                       return 1694;
   13173                                                     }
   13174                                                 }
   13175                                             }
   13176                                           else
   13177                                             {
   13178                                               if (((word >> 31) & 0x1) == 0)
   13179                                                 {
   13180                                                   if (((word >> 4) & 0x1) == 0)
   13181                                                     {
   13182                                                       if (((word >> 9) & 0x1) == 0)
   13183                                                         {
   13184                                                           if (((word >> 20) & 0x1) == 0)
   13185                                                             {
   13186                                                               /* 33222222222211111111110000000000
   13187                                                                  10987654321098765432109876543210
   13188                                                                  001001x11100xxxx01xxxx0xxxx0xxxx
   13189                                                                  orrs.  */
   13190                                                               return 1762;
   13191                                                             }
   13192                                                           else
   13193                                                             {
   13194                                                               /* 33222222222211111111110000000000
   13195                                                                  10987654321098765432109876543210
   13196                                                                  001001x11101xxxx01xxxx0xxxx0xxxx
   13197                                                                  brkbs.  */
   13198                                                               return 1306;
   13199                                                             }
   13200                                                         }
   13201                                                       else
   13202                                                         {
   13203                                                           /* 33222222222211111111110000000000
   13204                                                              10987654321098765432109876543210
   13205                                                              001001x1110xxxxx01xxxx1xxxx0xxxx
   13206                                                              nors.  */
   13207                                                           return 1754;
   13208                                                         }
   13209                                                     }
   13210                                                   else
   13211                                                     {
   13212                                                       if (((word >> 9) & 0x1) == 0)
   13213                                                         {
   13214                                                           /* 33222222222211111111110000000000
   13215                                                              10987654321098765432109876543210
   13216                                                              001001x1110xxxxx01xxxx0xxxx1xxxx
   13217                                                              orns.  */
   13218                                                           return 1757;
   13219                                                         }
   13220                                                       else
   13221                                                         {
   13222                                                           /* 33222222222211111111110000000000
   13223                                                              10987654321098765432109876543210
   13224                                                              001001x1110xxxxx01xxxx1xxxx1xxxx
   13225                                                              nands.  */
   13226                                                           return 1751;
   13227                                                         }
   13228                                                     }
   13229                                                 }
   13230                                               else
   13231                                                 {
   13232                                                   if (((word >> 13) & 0x1) == 0)
   13233                                                     {
   13234                                                       /* 33222222222211111111110000000000
   13235                                                          10987654321098765432109876543210
   13236                                                          101001x1110xxxxx010xxxxxxxxxxxxx
   13237                                                          ld1sb.  */
   13238                                                       return 1565;
   13239                                                     }
   13240                                                   else
   13241                                                     {
   13242                                                       /* 33222222222211111111110000000000
   13243                                                          10987654321098765432109876543210
   13244                                                          101001x1110xxxxx011xxxxxxxxxxxxx
   13245                                                          ldff1sb.  */
   13246                                                       return 1667;
   13247                                                     }
   13248                                                 }
   13249                                             }
   13250                                         }
   13251                                     }
   13252                                   else
   13253                                     {
   13254                                       if (((word >> 13) & 0x1) == 0)
   13255                                         {
   13256                                           if (((word >> 22) & 0x1) == 0)
   13257                                             {
   13258                                               if (((word >> 23) & 0x1) == 0)
   13259                                                 {
   13260                                                   /* 33222222222211111111110000000000
   13261                                                      10987654321098765432109876543210
   13262                                                      x01001x1001xxxxx010xxxxxxxxxxxxx
   13263                                                      ld1sh.  */
   13264                                                   return 1576;
   13265                                                 }
   13266                                               else
   13267                                                 {
   13268                                                   /* 33222222222211111111110000000000
   13269                                                      10987654321098765432109876543210
   13270                                                      x01001x1101xxxxx010xxxxxxxxxxxxx
   13271                                                      ld1sb.  */
   13272                                                   return 1564;
   13273                                                 }
   13274                                             }
   13275                                           else
   13276                                             {
   13277                                               if (((word >> 23) & 0x1) == 0)
   13278                                                 {
   13279                                                   /* 33222222222211111111110000000000
   13280                                                      10987654321098765432109876543210
   13281                                                      x01001x1011xxxxx010xxxxxxxxxxxxx
   13282                                                      ld1w.  */
   13283                                                   return 1595;
   13284                                                 }
   13285                                               else
   13286                                                 {
   13287                                                   /* 33222222222211111111110000000000
   13288                                                      10987654321098765432109876543210
   13289                                                      x01001x1111xxxxx010xxxxxxxxxxxxx
   13290                                                      ld1d.  */
   13291                                                   return 1517;
   13292                                                 }
   13293                                             }
   13294                                         }
   13295                                       else
   13296                                         {
   13297                                           if (((word >> 22) & 0x1) == 0)
   13298                                             {
   13299                                               if (((word >> 23) & 0x1) == 0)
   13300                                                 {
   13301                                                   /* 33222222222211111111110000000000
   13302                                                      10987654321098765432109876543210
   13303                                                      x01001x1001xxxxx011xxxxxxxxxxxxx
   13304                                                      ldff1sh.  */
   13305                                                   return 1677;
   13306                                                 }
   13307                                               else
   13308                                                 {
   13309                                                   /* 33222222222211111111110000000000
   13310                                                      10987654321098765432109876543210
   13311                                                      x01001x1101xxxxx011xxxxxxxxxxxxx
   13312                                                      ldff1sb.  */
   13313                                                   return 1665;
   13314                                                 }
   13315                                             }
   13316                                           else
   13317                                             {
   13318                                               if (((word >> 23) & 0x1) == 0)
   13319                                                 {
   13320                                                   /* 33222222222211111111110000000000
   13321                                                      10987654321098765432109876543210
   13322                                                      x01001x1011xxxxx011xxxxxxxxxxxxx
   13323                                                      ldff1w.  */
   13324                                                   return 1696;
   13325                                                 }
   13326                                               else
   13327                                                 {
   13328                                                   /* 33222222222211111111110000000000
   13329                                                      10987654321098765432109876543210
   13330                                                      x01001x1111xxxxx011xxxxxxxxxxxxx
   13331                                                      ldff1d.  */
   13332                                                   return 1641;
   13333                                                 }
   13334                                             }
   13335                                         }
   13336                                     }
   13337                                 }
   13338                               else
   13339                                 {
   13340                                   if (((word >> 13) & 0x1) == 0)
   13341                                     {
   13342                                       if (((word >> 31) & 0x1) == 0)
   13343                                         {
   13344                                           if (((word >> 21) & 0x1) == 0)
   13345                                             {
   13346                                               if (((word >> 4) & 0x1) == 0)
   13347                                                 {
   13348                                                   /* 33222222222211111111110000000000
   13349                                                      10987654321098765432109876543210
   13350                                                      011001x1xx0xxxxx010xxxxxxxx0xxxx
   13351                                                      fcmge.  */
   13352                                                   return 1396;
   13353                                                 }
   13354                                               else
   13355                                                 {
   13356                                                   /* 33222222222211111111110000000000
   13357                                                      10987654321098765432109876543210
   13358                                                      011001x1xx0xxxxx010xxxxxxxx1xxxx
   13359                                                      fcmgt.  */
   13360                                                   return 1398;
   13361                                                 }
   13362                                             }
   13363                                           else
   13364                                             {
   13365                                               /* 33222222222211111111110000000000
   13366                                                  10987654321098765432109876543210
   13367                                                  011001x1xx1xxxxx010xxxxxxxxxxxxx
   13368                                                  fnmla.  */
   13369                                               return 1460;
   13370                                             }
   13371                                         }
   13372                                       else
   13373                                         {
   13374                                           if (((word >> 22) & 0x1) == 0)
   13375                                             {
   13376                                               /* 33222222222211111111110000000000
   13377                                                  10987654321098765432109876543210
   13378                                                  111001x1x0xxxxxx010xxxxxxxxxxxxx
   13379                                                  str.  */
   13380                                               return 1946;
   13381                                             }
   13382                                           else
   13383                                             {
   13384                                               if (((word >> 21) & 0x1) == 0)
   13385                                                 {
   13386                                                   /* 33222222222211111111110000000000
   13387                                                      10987654321098765432109876543210
   13388                                                      111001x1x10xxxxx010xxxxxxxxxxxxx
   13389                                                      st1w.  */
   13390                                                   return 1905;
   13391                                                 }
   13392                                               else
   13393                                                 {
   13394                                                   if (((word >> 23) & 0x1) == 0)
   13395                                                     {
   13396                                                       /* 33222222222211111111110000000000
   13397                                                          10987654321098765432109876543210
   13398                                                          111001x1011xxxxx010xxxxxxxxxxxxx
   13399                                                          st1w.  */
   13400                                                       return 1907;
   13401                                                     }
   13402                                                   else
   13403                                                     {
   13404                                                       /* 33222222222211111111110000000000
   13405                                                          10987654321098765432109876543210
   13406                                                          111001x1111xxxxx010xxxxxxxxxxxxx
   13407                                                          st1d.  */
   13408                                                       return 1884;
   13409                                                     }
   13410                                                 }
   13411                                             }
   13412                                         }
   13413                                     }
   13414                                   else
   13415                                     {
   13416                                       if (((word >> 21) & 0x1) == 0)
   13417                                         {
   13418                                           if (((word >> 31) & 0x1) == 0)
   13419                                             {
   13420                                               if (((word >> 4) & 0x1) == 0)
   13421                                                 {
   13422                                                   /* 33222222222211111111110000000000
   13423                                                      10987654321098765432109876543210
   13424                                                      011001x1xx0xxxxx011xxxxxxxx0xxxx
   13425                                                      fcmeq.  */
   13426                                                   return 1394;
   13427                                                 }
   13428                                               else
   13429                                                 {
   13430                                                   /* 33222222222211111111110000000000
   13431                                                      10987654321098765432109876543210
   13432                                                      011001x1xx0xxxxx011xxxxxxxx1xxxx
   13433                                                      fcmne.  */
   13434                                                   return 1402;
   13435                                                 }
   13436                                             }
   13437                                           else
   13438                                             {
   13439                                               if (((word >> 22) & 0x1) == 0)
   13440                                                 {
   13441                                                   if (((word >> 23) & 0x1) == 0)
   13442                                                     {
   13443                                                       /* 33222222222211111111110000000000
   13444                                                          10987654321098765432109876543210
   13445                                                          111001x1000xxxxx011xxxxxxxxxxxxx
   13446                                                          stnt1w.  */
   13447                                                       return 1943;
   13448                                                     }
   13449                                                   else
   13450                                                     {
   13451                                                       /* 33222222222211111111110000000000
   13452                                                          10987654321098765432109876543210
   13453                                                          111001x1100xxxxx011xxxxxxxxxxxxx
   13454                                                          stnt1d.  */
   13455                                                       return 1939;
   13456                                                     }
   13457                                                 }
   13458                                               else
   13459                                                 {
   13460                                                   if (((word >> 23) & 0x1) == 0)
   13461                                                     {
   13462                                                       /* 33222222222211111111110000000000
   13463                                                          10987654321098765432109876543210
   13464                                                          111001x1010xxxxx011xxxxxxxxxxxxx
   13465                                                          st3w.  */
   13466                                                       return 1927;
   13467                                                     }
   13468                                                   else
   13469                                                     {
   13470                                                       /* 33222222222211111111110000000000
   13471                                                          10987654321098765432109876543210
   13472                                                          111001x1110xxxxx011xxxxxxxxxxxxx
   13473                                                          st3d.  */
   13474                                                       return 1923;
   13475                                                     }
   13476                                                 }
   13477                                             }
   13478                                         }
   13479                                       else
   13480                                         {
   13481                                           if (((word >> 31) & 0x1) == 0)
   13482                                             {
   13483                                               /* 33222222222211111111110000000000
   13484                                                  10987654321098765432109876543210
   13485                                                  011001x1xx1xxxxx011xxxxxxxxxxxxx
   13486                                                  fnmls.  */
   13487                                               return 1461;
   13488                                             }
   13489                                           else
   13490                                             {
   13491                                               if (((word >> 22) & 0x1) == 0)
   13492                                                 {
   13493                                                   if (((word >> 23) & 0x1) == 0)
   13494                                                     {
   13495                                                       /* 33222222222211111111110000000000
   13496                                                          10987654321098765432109876543210
   13497                                                          111001x1001xxxxx011xxxxxxxxxxxxx
   13498                                                          st2w.  */
   13499                                                       return 1919;
   13500                                                     }
   13501                                                   else
   13502                                                     {
   13503                                                       /* 33222222222211111111110000000000
   13504                                                          10987654321098765432109876543210
   13505                                                          111001x1101xxxxx011xxxxxxxxxxxxx
   13506                                                          st2d.  */
   13507                                                       return 1915;
   13508                                                     }
   13509                                                 }
   13510                                               else
   13511                                                 {
   13512                                                   if (((word >> 23) & 0x1) == 0)
   13513                                                     {
   13514                                                       /* 33222222222211111111110000000000
   13515                                                          10987654321098765432109876543210
   13516                                                          111001x1011xxxxx011xxxxxxxxxxxxx
   13517                                                          st4w.  */
   13518                                                       return 1935;
   13519                                                     }
   13520                                                   else
   13521                                                     {
   13522                                                       /* 33222222222211111111110000000000
   13523                                                          10987654321098765432109876543210
   13524                                                          111001x1111xxxxx011xxxxxxxxxxxxx
   13525                                                          st4d.  */
   13526                                                       return 1931;
   13527                                                     }
   13528                                                 }
   13529                                             }
   13530                                         }
   13531                                     }
   13532                                 }
   13533                             }
   13534                         }
   13535                       else
   13536                         {
   13537                           if (((word >> 21) & 0x1) == 0)
   13538                             {
   13539                               if (((word >> 30) & 0x1) == 0)
   13540                                 {
   13541                                   if (((word >> 14) & 0x1) == 0)
   13542                                     {
   13543                                       if (((word >> 13) & 0x1) == 0)
   13544                                         {
   13545                                           if (((word >> 4) & 0x1) == 0)
   13546                                             {
   13547                                               /* 33222222222211111111110000000000
   13548                                                  10987654321098765432109876543210
   13549                                                  x01001x1xx0xxxxx100xxxxxxxx0xxxx
   13550                                                  cmpeq.  */
   13551                                               return 1323;
   13552                                             }
   13553                                           else
   13554                                             {
   13555                                               /* 33222222222211111111110000000000
   13556                                                  10987654321098765432109876543210
   13557                                                  x01001x1xx0xxxxx100xxxxxxxx1xxxx
   13558                                                  cmpne.  */
   13559                                               return 1346;
   13560                                             }
   13561                                         }
   13562                                       else
   13563                                         {
   13564                                           if (((word >> 20) & 0x1) == 0)
   13565                                             {
   13566                                               if (((word >> 22) & 0x1) == 0)
   13567                                                 {
   13568                                                   if (((word >> 23) & 0x1) == 0)
   13569                                                     {
   13570                                                       /* 33222222222211111111110000000000
   13571                                                          10987654321098765432109876543210
   13572                                                          x01001x10000xxxx101xxxxxxxxxxxxx
   13573                                                          ld1sh.  */
   13574                                                       return 1582;
   13575                                                     }
   13576                                                   else
   13577                                                     {
   13578                                                       /* 33222222222211111111110000000000
   13579                                                          10987654321098765432109876543210
   13580                                                          x01001x11000xxxx101xxxxxxxxxxxxx
   13581                                                          ld1sb.  */
   13582                                                       return 1569;
   13583                                                     }
   13584                                                 }
   13585                                               else
   13586                                                 {
   13587                                                   if (((word >> 23) & 0x1) == 0)
   13588                                                     {
   13589                                                       /* 33222222222211111111110000000000
   13590                                                          10987654321098765432109876543210
   13591                                                          x01001x10100xxxx101xxxxxxxxxxxxx
   13592                                                          ld1w.  */
   13593                                                       return 1601;
   13594                                                     }
   13595                                                   else
   13596                                                     {
   13597                                                       /* 33222222222211111111110000000000
   13598                                                          10987654321098765432109876543210
   13599                                                          x01001x11100xxxx101xxxxxxxxxxxxx
   13600                                                          ld1sb.  */
   13601                                                       return 1571;
   13602                                                     }
   13603                                                 }
   13604                                             }
   13605                                           else
   13606                                             {
   13607                                               if (((word >> 22) & 0x1) == 0)
   13608                                                 {
   13609                                                   if (((word >> 23) & 0x1) == 0)
   13610                                                     {
   13611                                                       /* 33222222222211111111110000000000
   13612                                                          10987654321098765432109876543210
   13613                                                          x01001x10001xxxx101xxxxxxxxxxxxx
   13614                                                          ldnf1sh.  */
   13615                                                       return 1715;
   13616                                                     }
   13617                                                   else
   13618                                                     {
   13619                                                       /* 33222222222211111111110000000000
   13620                                                          10987654321098765432109876543210
   13621                                                          x01001x11001xxxx101xxxxxxxxxxxxx
   13622                                                          ldnf1sb.  */
   13623                                                       return 1712;
   13624                                                     }
   13625                                                 }
   13626                                               else
   13627                                                 {
   13628                                                   if (((word >> 23) & 0x1) == 0)
   13629                                                     {
   13630                                                       /* 33222222222211111111110000000000
   13631                                                          10987654321098765432109876543210
   13632                                                          x01001x10101xxxx101xxxxxxxxxxxxx
   13633                                                          ldnf1w.  */
   13634                                                       return 1718;
   13635                                                     }
   13636                                                   else
   13637                                                     {
   13638                                                       /* 33222222222211111111110000000000
   13639                                                          10987654321098765432109876543210
   13640                                                          x01001x11101xxxx101xxxxxxxxxxxxx
   13641                                                          ldnf1sb.  */
   13642                                                       return 1714;
   13643                                                     }
   13644                                                 }
   13645                                             }
   13646                                         }
   13647                                     }
   13648                                   else
   13649                                     {
   13650                                       if (((word >> 31) & 0x1) == 0)
   13651                                         {
   13652                                           if (((word >> 4) & 0x1) == 0)
   13653                                             {
   13654                                               if (((word >> 20) & 0x1) == 0)
   13655                                                 {
   13656                                                   if (((word >> 22) & 0x1) == 0)
   13657                                                     {
   13658                                                       /* 33222222222211111111110000000000
   13659                                                          10987654321098765432109876543210
   13660                                                          001001x1x000xxxx11xxxxxxxxx0xxxx
   13661                                                          brkpa.  */
   13662                                                       return 1309;
   13663                                                     }
   13664                                                   else
   13665                                                     {
   13666                                                       /* 33222222222211111111110000000000
   13667                                                          10987654321098765432109876543210
   13668                                                          001001x1x100xxxx11xxxxxxxxx0xxxx
   13669                                                          brkpas.  */
   13670                                                       return 1310;
   13671                                                     }
   13672                                                 }
   13673                                               else
   13674                                                 {
   13675                                                   if (((word >> 16) & 0x1) == 0)
   13676                                                     {
   13677                                                       if (((word >> 19) & 0x1) == 0)
   13678                                                         {
   13679                                                           /* 33222222222211111111110000000000
   13680                                                              10987654321098765432109876543210
   13681                                                              001001x1xx010xx011xxxxxxxxx0xxxx
   13682                                                              ptest.  */
   13683                                                           return 1795;
   13684                                                         }
   13685                                                       else
   13686                                                         {
   13687                                                           if (((word >> 10) & 0x1) == 0)
   13688                                                             {
   13689                                                               if (((word >> 12) & 0x1) == 0)
   13690                                                                 {
   13691                                                                   if (((word >> 13) & 0x1) == 0)
   13692                                                                     {
   13693                                                                       /* 33222222222211111111110000000000
   13694                                                                          10987654321098765432109876543210
   13695                                                                          001001x1xx011xx01100x0xxxxx0xxxx
   13696                                                                          pfirst.  */
   13697                                                                       return 1765;
   13698                                                                     }
   13699                                                                   else
   13700                                                                     {
   13701                                                                       /* 33222222222211111111110000000000
   13702                                                                          10987654321098765432109876543210
   13703                                                                          001001x1xx011xx01110x0xxxxx0xxxx
   13704                                                                          ptrue.  */
   13705                                                                       return 1796;
   13706                                                                     }
   13707                                                                 }
   13708                                                               else
   13709                                                                 {
   13710                                                                   if (((word >> 22) & 0x1) == 0)
   13711                                                                     {
   13712                                                                       /* 33222222222211111111110000000000
   13713                                                                          10987654321098765432109876543210
   13714                                                                          001001x1x0011xx011x1x0xxxxx0xxxx
   13715                                                                          rdffr.  */
   13716                                                                       return 1802;
   13717                                                                     }
   13718                                                                   else
   13719                                                                     {
   13720                                                                       /* 33222222222211111111110000000000
   13721                                                                          10987654321098765432109876543210
   13722                                                                          001001x1x1011xx011x1x0xxxxx0xxxx
   13723                                                                          rdffrs.  */
   13724                                                                       return 1803;
   13725                                                                     }
   13726                                                                 }
   13727                                                             }
   13728                                                           else
   13729                                                             {
   13730                                                               /* 33222222222211111111110000000000
   13731                                                                  10987654321098765432109876543210
   13732                                                                  001001x1xx011xx011xxx1xxxxx0xxxx
   13733                                                                  pfalse.  */
   13734                                                               return 1764;
   13735                                                             }
   13736                                                         }
   13737                                                     }
   13738                                                   else
   13739                                                     {
   13740                                                       if (((word >> 10) & 0x1) == 0)
   13741                                                         {
   13742                                                           if (((word >> 12) & 0x1) == 0)
   13743                                                             {
   13744                                                               /* 33222222222211111111110000000000
   13745                                                                  10987654321098765432109876543210
   13746                                                                  001001x1xx01xxx111x0x0xxxxx0xxxx
   13747                                                                  ptrues.  */
   13748                                                               return 1797;
   13749                                                             }
   13750                                                           else
   13751                                                             {
   13752                                                               /* 33222222222211111111110000000000
   13753                                                                  10987654321098765432109876543210
   13754                                                                  001001x1xx01xxx111x1x0xxxxx0xxxx
   13755                                                                  rdffr.  */
   13756                                                               return 1801;
   13757                                                             }
   13758                                                         }
   13759                                                       else
   13760                                                         {
   13761                                                           /* 33222222222211111111110000000000
   13762                                                              10987654321098765432109876543210
   13763                                                              001001x1xx01xxx111xxx1xxxxx0xxxx
   13764                                                              pnext.  */
   13765                                                           return 1766;
   13766                                                         }
   13767                                                     }
   13768                                                 }
   13769                                             }
   13770                                           else
   13771                                             {
   13772                                               if (((word >> 22) & 0x1) == 0)
   13773                                                 {
   13774                                                   /* 33222222222211111111110000000000
   13775                                                      10987654321098765432109876543210
   13776                                                      001001x1x00xxxxx11xxxxxxxxx1xxxx
   13777                                                      brkpb.  */
   13778                                                   return 1311;
   13779                                                 }
   13780                                               else
   13781                                                 {
   13782                                                   /* 33222222222211111111110000000000
   13783                                                      10987654321098765432109876543210
   13784                                                      001001x1x10xxxxx11xxxxxxxxx1xxxx
   13785                                                      brkpbs.  */
   13786                                                   return 1312;
   13787                                                 }
   13788                                             }
   13789                                         }
   13790                                       else
   13791                                         {
   13792                                           if (((word >> 13) & 0x1) == 0)
   13793                                             {
   13794                                               if (((word >> 22) & 0x1) == 0)
   13795                                                 {
   13796                                                   if (((word >> 23) & 0x1) == 0)
   13797                                                     {
   13798                                                       /* 33222222222211111111110000000000
   13799                                                          10987654321098765432109876543210
   13800                                                          101001x1000xxxxx110xxxxxxxxxxxxx
   13801                                                          ldnt1w.  */
   13802                                                       return 1726;
   13803                                                     }
   13804                                                   else
   13805                                                     {
   13806                                                       /* 33222222222211111111110000000000
   13807                                                          10987654321098765432109876543210
   13808                                                          101001x1100xxxxx110xxxxxxxxxxxxx
   13809                                                          ldnt1d.  */
   13810                                                       return 1722;
   13811                                                     }
   13812                                                 }
   13813                                               else
   13814                                                 {
   13815                                                   if (((word >> 23) & 0x1) == 0)
   13816                                                     {
   13817                                                       /* 33222222222211111111110000000000
   13818                                                          10987654321098765432109876543210
   13819                                                          101001x1010xxxxx110xxxxxxxxxxxxx
   13820                                                          ld3w.  */
   13821                                                       return 1618;
   13822                                                     }
   13823                                                   else
   13824                                                     {
   13825                                                       /* 33222222222211111111110000000000
   13826                                                          10987654321098765432109876543210
   13827                                                          101001x1110xxxxx110xxxxxxxxxxxxx
   13828                                                          ld3d.  */
   13829                                                       return 1614;
   13830                                                     }
   13831                                                 }
   13832                                             }
   13833                                           else
   13834                                             {
   13835                                               if (((word >> 22) & 0x1) == 0)
   13836                                                 {
   13837                                                   if (((word >> 23) & 0x1) == 0)
   13838                                                     {
   13839                                                       /* 33222222222211111111110000000000
   13840                                                          10987654321098765432109876543210
   13841                                                          101001x1000xxxxx111xxxxxxxxxxxxx
   13842                                                          ldnt1w.  */
   13843                                                       return 1727;
   13844                                                     }
   13845                                                   else
   13846                                                     {
   13847                                                       /* 33222222222211111111110000000000
   13848                                                          10987654321098765432109876543210
   13849                                                          101001x1100xxxxx111xxxxxxxxxxxxx
   13850                                                          ldnt1d.  */
   13851                                                       return 1723;
   13852                                                     }
   13853                                                 }
   13854                                               else
   13855                                                 {
   13856                                                   if (((word >> 23) & 0x1) == 0)
   13857                                                     {
   13858                                                       /* 33222222222211111111110000000000
   13859                                                          10987654321098765432109876543210
   13860                                                          101001x1010xxxxx111xxxxxxxxxxxxx
   13861                                                          ld3w.  */
   13862                                                       return 1619;
   13863                                                     }
   13864                                                   else
   13865                                                     {
   13866                                                       /* 33222222222211111111110000000000
   13867                                                          10987654321098765432109876543210
   13868                                                          101001x1110xxxxx111xxxxxxxxxxxxx
   13869                                                          ld3d.  */
   13870                                                       return 1615;
   13871                                                     }
   13872                                                 }
   13873                                             }
   13874                                         }
   13875                                     }
   13876                                 }
   13877                               else
   13878                                 {
   13879                                   if (((word >> 13) & 0x1) == 0)
   13880                                     {
   13881                                       if (((word >> 31) & 0x1) == 0)
   13882                                         {
   13883                                           if (((word >> 14) & 0x1) == 0)
   13884                                             {
   13885                                               if (((word >> 19) & 0x1) == 0)
   13886                                                 {
   13887                                                   if (((word >> 20) & 0x1) == 0)
   13888                                                     {
   13889                                                       if (((word >> 16) & 0x1) == 0)
   13890                                                         {
   13891                                                           if (((word >> 17) & 0x1) == 0)
   13892                                                             {
   13893                                                               if (((word >> 18) & 0x1) == 0)
   13894                                                                 {
   13895                                                                   /* 33222222222211111111110000000000
   13896                                                                      10987654321098765432109876543210
   13897                                                                      011001x1xx000000100xxxxxxxxxxxxx
   13898                                                                      fadd.  */
   13899                                                                   return 1385;
   13900                                                                 }
   13901                                                               else
   13902                                                                 {
   13903                                                                   /* 33222222222211111111110000000000
   13904                                                                      10987654321098765432109876543210
   13905                                                                      011001x1xx000100100xxxxxxxxxxxxx
   13906                                                                      fmaxnm.  */
   13907                                                                   return 1432;
   13908                                                                 }
   13909                                                             }
   13910                                                           else
   13911                                                             {
   13912                                                               if (((word >> 18) & 0x1) == 0)
   13913                                                                 {
   13914                                                                   /* 33222222222211111111110000000000
   13915                                                                      10987654321098765432109876543210
   13916                                                                      011001x1xx000010100xxxxxxxxxxxxx
   13917                                                                      fmul.  */
   13918                                                                   return 1452;
   13919                                                                 }
   13920                                                               else
   13921                                                                 {
   13922                                                                   /* 33222222222211111111110000000000
   13923                                                                      10987654321098765432109876543210
   13924                                                                      011001x1xx000110100xxxxxxxxxxxxx
   13925                                                                      fmax.  */
   13926                                                                   return 1430;
   13927                                                                 }
   13928                                                             }
   13929                                                         }
   13930                                                       else
   13931                                                         {
   13932                                                           if (((word >> 17) & 0x1) == 0)
   13933                                                             {
   13934                                                               if (((word >> 18) & 0x1) == 0)
   13935                                                                 {
   13936                                                                   /* 33222222222211111111110000000000
   13937                                                                      10987654321098765432109876543210
   13938                                                                      011001x1xx000001100xxxxxxxxxxxxx
   13939                                                                      fsub.  */
   13940                                                                   return 1478;
   13941                                                                 }
   13942                                                               else
   13943                                                                 {
   13944                                                                   /* 33222222222211111111110000000000
   13945                                                                      10987654321098765432109876543210
   13946                                                                      011001x1xx000101100xxxxxxxxxxxxx
   13947                                                                      fminnm.  */
   13948                                                                   return 1438;
   13949                                                                 }
   13950                                                             }
   13951                                                           else
   13952                                                             {
   13953                                                               if (((word >> 18) & 0x1) == 0)
   13954                                                                 {
   13955                                                                   /* 33222222222211111111110000000000
   13956                                                                      10987654321098765432109876543210
   13957                                                                      011001x1xx000011100xxxxxxxxxxxxx
   13958                                                                      fsubr.  */
   13959                                                                   return 1480;
   13960                                                                 }
   13961                                                               else
   13962                                                                 {
   13963                                                                   /* 33222222222211111111110000000000
   13964                                                                      10987654321098765432109876543210
   13965                                                                      011001x1xx000111100xxxxxxxxxxxxx
   13966                                                                      fmin.  */
   13967                                                                   return 1436;
   13968                                                                 }
   13969                                                             }
   13970                                                         }
   13971                                                     }
   13972                                                   else
   13973                                                     {
   13974                                                       /* 33222222222211111111110000000000
   13975                                                          10987654321098765432109876543210
   13976                                                          011001x1xx010xxx100xxxxxxxxxxxxx
   13977                                                          ftmad.  */
   13978                                                       return 1482;
   13979                                                     }
   13980                                                 }
   13981                                               else
   13982                                                 {
   13983                                                   if (((word >> 16) & 0x1) == 0)
   13984                                                     {
   13985                                                       if (((word >> 17) & 0x1) == 0)
   13986                                                         {
   13987                                                           if (((word >> 18) & 0x1) == 0)
   13988                                                             {
   13989                                                               if (((word >> 20) & 0x1) == 0)
   13990                                                                 {
   13991                                                                   /* 33222222222211111111110000000000
   13992                                                                      10987654321098765432109876543210
   13993                                                                      011001x1xx001000100xxxxxxxxxxxxx
   13994                                                                      fabd.  */
   13995                                                                   return 1380;
   13996                                                                 }
   13997                                                               else
   13998                                                                 {
   13999                                                                   /* 33222222222211111111110000000000
   14000                                                                      10987654321098765432109876543210
   14001                                                                      011001x1xx011000100xxxxxxxxxxxxx
   14002                                                                      fadd.  */
   14003                                                                   return 1386;
   14004                                                                 }
   14005                                                             }
   14006                                                           else
   14007                                                             {
   14008                                                               if (((word >> 20) & 0x1) == 0)
   14009                                                                 {
   14010                                                                   /* 33222222222211111111110000000000
   14011                                                                      10987654321098765432109876543210
   14012                                                                      011001x1xx001100100xxxxxxxxxxxxx
   14013                                                                      fdivr.  */
   14014                                                                   return 1426;
   14015                                                                 }
   14016                                                               else
   14017                                                                 {
   14018                                                                   /* 33222222222211111111110000000000
   14019                                                                      10987654321098765432109876543210
   14020                                                                      011001x1xx011100100xxxxxxxxxxxxx
   14021                                                                      fmaxnm.  */
   14022                                                                   return 1433;
   14023                                                                 }
   14024                                                             }
   14025                                                         }
   14026                                                       else
   14027                                                         {
   14028                                                           if (((word >> 18) & 0x1) == 0)
   14029                                                             {
   14030                                                               if (((word >> 20) & 0x1) == 0)
   14031                                                                 {
   14032                                                                   /* 33222222222211111111110000000000
   14033                                                                      10987654321098765432109876543210
   14034                                                                      011001x1xx001010100xxxxxxxxxxxxx
   14035                                                                      fmulx.  */
   14036                                                                   return 1457;
   14037                                                                 }
   14038                                                               else
   14039                                                                 {
   14040                                                                   /* 33222222222211111111110000000000
   14041                                                                      10987654321098765432109876543210
   14042                                                                      011001x1xx011010100xxxxxxxxxxxxx
   14043                                                                      fmul.  */
   14044                                                                   return 1453;
   14045                                                                 }
   14046                                                             }
   14047                                                           else
   14048                                                             {
   14049                                                               /* 33222222222211111111110000000000
   14050                                                                  10987654321098765432109876543210
   14051                                                                  011001x1xx0x1110100xxxxxxxxxxxxx
   14052                                                                  fmax.  */
   14053                                                               return 1431;
   14054                                                             }
   14055                                                         }
   14056                                                     }
   14057                                                   else
   14058                                                     {
   14059                                                       if (((word >> 17) & 0x1) == 0)
   14060                                                         {
   14061                                                           if (((word >> 18) & 0x1) == 0)
   14062                                                             {
   14063                                                               if (((word >> 20) & 0x1) == 0)
   14064                                                                 {
   14065                                                                   /* 33222222222211111111110000000000
   14066                                                                      10987654321098765432109876543210
   14067                                                                      011001x1xx001001100xxxxxxxxxxxxx
   14068                                                                      fscale.  */
   14069                                                                   return 1475;
   14070                                                                 }
   14071                                                               else
   14072                                                                 {
   14073                                                                   /* 33222222222211111111110000000000
   14074                                                                      10987654321098765432109876543210
   14075                                                                      011001x1xx011001100xxxxxxxxxxxxx
   14076                                                                      fsub.  */
   14077                                                                   return 1479;
   14078                                                                 }
   14079                                                             }
   14080                                                           else
   14081                                                             {
   14082                                                               if (((word >> 20) & 0x1) == 0)
   14083                                                                 {
   14084                                                                   /* 33222222222211111111110000000000
   14085                                                                      10987654321098765432109876543210
   14086                                                                      011001x1xx001101100xxxxxxxxxxxxx
   14087                                                                      fdiv.  */
   14088                                                                   return 1425;
   14089                                                                 }
   14090                                                               else
   14091                                                                 {
   14092                                                                   /* 33222222222211111111110000000000
   14093                                                                      10987654321098765432109876543210
   14094                                                                      011001x1xx011101100xxxxxxxxxxxxx
   14095                                                                      fminnm.  */
   14096                                                                   return 1439;
   14097                                                                 }
   14098                                                             }
   14099                                                         }
   14100                                                       else
   14101                                                         {
   14102                                                           if (((word >> 18) & 0x1) == 0)
   14103                                                             {
   14104                                                               /* 33222222222211111111110000000000
   14105                                                                  10987654321098765432109876543210
   14106                                                                  011001x1xx0x1011100xxxxxxxxxxxxx
   14107                                                                  fsubr.  */
   14108                                                               return 1481;
   14109                                                             }
   14110                                                           else
   14111                                                             {
   14112                                                               /* 33222222222211111111110000000000
   14113                                                                  10987654321098765432109876543210
   14114                                                                  011001x1xx0x1111100xxxxxxxxxxxxx
   14115                                                                  fmin.  */
   14116                                                               return 1437;
   14117                                                             }
   14118                                                         }
   14119                                                     }
   14120                                                 }
   14121                                             }
   14122                                           else
   14123                                             {
   14124                                               if (((word >> 4) & 0x1) == 0)
   14125                                                 {
   14126                                                   /* 33222222222211111111110000000000
   14127                                                      10987654321098765432109876543210
   14128                                                      011001x1xx0xxxxx110xxxxxxxx0xxxx
   14129                                                      fcmuo.  */
   14130                                                   return 1403;
   14131                                                 }
   14132                                               else
   14133                                                 {
   14134                                                   /* 33222222222211111111110000000000
   14135                                                      10987654321098765432109876543210
   14136                                                      011001x1xx0xxxxx110xxxxxxxx1xxxx
   14137                                                      facge.  */
   14138                                                   return 1382;
   14139                                                 }
   14140                                             }
   14141                                         }
   14142                                       else
   14143                                         {
   14144                                           if (((word >> 22) & 0x1) == 0)
   14145                                             {
   14146                                               if (((word >> 23) & 0x1) == 0)
   14147                                                 {
   14148                                                   /* 33222222222211111111110000000000
   14149                                                      10987654321098765432109876543210
   14150                                                      111001x1000xxxxx1x0xxxxxxxxxxxxx
   14151                                                      st1w.  */
   14152                                                   return 1901;
   14153                                                 }
   14154                                               else
   14155                                                 {
   14156                                                   /* 33222222222211111111110000000000
   14157                                                      10987654321098765432109876543210
   14158                                                      111001x1100xxxxx1x0xxxxxxxxxxxxx
   14159                                                      st1d.  */
   14160                                                   return 1880;
   14161                                                 }
   14162                                             }
   14163                                           else
   14164                                             {
   14165                                               /* 33222222222211111111110000000000
   14166                                                  10987654321098765432109876543210
   14167                                                  111001x1x10xxxxx1x0xxxxxxxxxxxxx
   14168                                                  st1w.  */
   14169                                               return 1906;
   14170                                             }
   14171                                         }
   14172                                     }
   14173                                   else
   14174                                     {
   14175                                       if (((word >> 14) & 0x1) == 0)
   14176                                         {
   14177                                           if (((word >> 31) & 0x1) == 0)
   14178                                             {
   14179                                               if (((word >> 16) & 0x1) == 0)
   14180                                                 {
   14181                                                   if (((word >> 19) & 0x1) == 0)
   14182                                                     {
   14183                                                       if (((word >> 17) & 0x1) == 0)
   14184                                                         {
   14185                                                           if (((word >> 18) & 0x1) == 0)
   14186                                                             {
   14187                                                               if (((word >> 20) & 0x1) == 0)
   14188                                                                 {
   14189                                                                   /* 33222222222211111111110000000000
   14190                                                                      10987654321098765432109876543210
   14191                                                                      011001x1xx000000101xxxxxxxxxxxxx
   14192                                                                      frintn.  */
   14193                                                                   return 1469;
   14194                                                                 }
   14195                                                               else
   14196                                                                 {
   14197                                                                   /* 33222222222211111111110000000000
   14198                                                                      10987654321098765432109876543210
   14199                                                                      011001x1xx010000101xxxxxxxxxxxxx
   14200                                                                      scvtf.  */
   14201                                                                   return 1815;
   14202                                                                 }
   14203                                                             }
   14204                                                           else
   14205                                                             {
   14206                                                               if (((word >> 20) & 0x1) == 0)
   14207                                                                 {
   14208                                                                   /* 33222222222211111111110000000000
   14209                                                                      10987654321098765432109876543210
   14210                                                                      011001x1xx000100101xxxxxxxxxxxxx
   14211                                                                      frinta.  */
   14212                                                                   return 1466;
   14213                                                                 }
   14214                                                               else
   14215                                                                 {
   14216                                                                   if (((word >> 22) & 0x1) == 0)
   14217                                                                     {
   14218                                                                       /* 33222222222211111111110000000000
   14219                                                                          10987654321098765432109876543210
   14220                                                                          011001x1x0010100101xxxxxxxxxxxxx
   14221                                                                          scvtf.  */
   14222                                                                       return 1814;
   14223                                                                     }
   14224                                                                   else
   14225                                                                     {
   14226                                                                       if (((word >> 23) & 0x1) == 0)
   14227                                                                         {
   14228                                                                           /* 33222222222211111111110000000000
   14229                                                                              10987654321098765432109876543210
   14230                                                                              011001x101010100101xxxxxxxxxxxxx
   14231                                                                              scvtf.  */
   14232                                                                           return 1813;
   14233                                                                         }
   14234                                                                       else
   14235                                                                         {
   14236                                                                           /* 33222222222211111111110000000000
   14237                                                                              10987654321098765432109876543210
   14238                                                                              011001x111010100101xxxxxxxxxxxxx
   14239                                                                              scvtf.  */
   14240                                                                           return 1817;
   14241                                                                         }
   14242                                                                     }
   14243                                                                 }
   14244                                                             }
   14245                                                         }
   14246                                                       else
   14247                                                         {
   14248                                                           if (((word >> 18) & 0x1) == 0)
   14249                                                             {
   14250                                                               if (((word >> 20) & 0x1) == 0)
   14251                                                                 {
   14252                                                                   /* 33222222222211111111110000000000
   14253                                                                      10987654321098765432109876543210
   14254                                                                      011001x1xx000010101xxxxxxxxxxxxx
   14255                                                                      frintm.  */
   14256                                                                   return 1468;
   14257                                                                 }
   14258                                                               else
   14259                                                                 {
   14260                                                                   /* 33222222222211111111110000000000
   14261                                                                      10987654321098765432109876543210
   14262                                                                      011001x1xx010010101xxxxxxxxxxxxx
   14263                                                                      scvtf.  */
   14264                                                                   return 1812;
   14265                                                                 }
   14266                                                             }
   14267                                                           else
   14268                                                             {
   14269                                                               if (((word >> 20) & 0x1) == 0)
   14270                                                                 {
   14271                                                                   /* 33222222222211111111110000000000
   14272                                                                      10987654321098765432109876543210
   14273                                                                      011001x1xx000110101xxxxxxxxxxxxx
   14274                                                                      frintx.  */
   14275                                                                   return 1471;
   14276                                                                 }
   14277                                                               else
   14278                                                                 {
   14279                                                                   if (((word >> 23) & 0x1) == 0)
   14280                                                                     {
   14281                                                                       /* 33222222222211111111110000000000
   14282                                                                          10987654321098765432109876543210
   14283                                                                          011001x10x010110101xxxxxxxxxxxxx
   14284                                                                          scvtf.  */
   14285                                                                       return 1816;
   14286                                                                     }
   14287                                                                   else
   14288                                                                     {
   14289                                                                       /* 33222222222211111111110000000000
   14290                                                                          10987654321098765432109876543210
   14291                                                                          011001x11x010110101xxxxxxxxxxxxx
   14292                                                                          scvtf.  */
   14293                                                                       return 1818;
   14294                                                                     }
   14295                                                                 }
   14296                                                             }
   14297                                                         }
   14298                                                     }
   14299                                                   else
   14300                                                     {
   14301                                                       if (((word >> 20) & 0x1) == 0)
   14302                                                         {
   14303                                                           if (((word >> 17) & 0x1) == 0)
   14304                                                             {
   14305                                                               if (((word >> 18) & 0x1) == 0)
   14306                                                                 {
   14307                                                                   if (((word >> 22) & 0x1) == 0)
   14308                                                                     {
   14309                                                                       /* 33222222222211111111110000000000
   14310                                                                          10987654321098765432109876543210
   14311                                                                          011001x1x0001000101xxxxxxxxxxxxx
   14312                                                                          fcvt.  */
   14313                                                                       return 1405;
   14314                                                                     }
   14315                                                                   else
   14316                                                                     {
   14317                                                                       /* 33222222222211111111110000000000
   14318                                                                          10987654321098765432109876543210
   14319                                                                          011001x1x1001000101xxxxxxxxxxxxx
   14320                                                                          fcvt.  */
   14321                                                                       return 1407;
   14322                                                                     }
   14323                                                                 }
   14324                                                               else
   14325                                                                 {
   14326                                                                   /* 33222222222211111111110000000000
   14327                                                                      10987654321098765432109876543210
   14328                                                                      011001x1xx001100101xxxxxxxxxxxxx
   14329                                                                      frecpx.  */
   14330                                                                   return 1465;
   14331                                                                 }
   14332                                                             }
   14333                                                           else
   14334                                                             {
   14335                                                               if (((word >> 22) & 0x1) == 0)
   14336                                                                 {
   14337                                                                   if (((word >> 23) & 0x1) == 0)
   14338                                                                     {
   14339                                                                       /* 33222222222211111111110000000000
   14340                                                                          10987654321098765432109876543210
   14341                                                                          011001x100001x10101xxxxxxxxxxxxx
   14342                                                                          fcvtx.  */
   14343                                                                       return 2075;
   14344                                                                     }
   14345                                                                   else
   14346                                                                     {
   14347                                                                       /* 33222222222211111111110000000000
   14348                                                                          10987654321098765432109876543210
   14349                                                                          011001x110001x10101xxxxxxxxxxxxx
   14350                                                                          bfcvt.  */
   14351                                                                       return 2425;
   14352                                                                     }
   14353                                                                 }
   14354                                                               else
   14355                                                                 {
   14356                                                                   /* 33222222222211111111110000000000
   14357                                                                      10987654321098765432109876543210
   14358                                                                      011001x1x1001x10101xxxxxxxxxxxxx
   14359                                                                      fcvt.  */
   14360                                                                   return 1409;
   14361                                                                 }
   14362                                                             }
   14363                                                         }
   14364                                                       else
   14365                                                         {
   14366                                                           if (((word >> 22) & 0x1) == 0)
   14367                                                             {
   14368                                                               if (((word >> 23) & 0x1) == 0)
   14369                                                                 {
   14370                                                                   /* 33222222222211111111110000000000
   14371                                                                      10987654321098765432109876543210
   14372                                                                      011001x100011xx0101xxxxxxxxxxxxx
   14373                                                                      flogb.  */
   14374                                                                   return 2077;
   14375                                                                 }
   14376                                                               else
   14377                                                                 {
   14378                                                                   /* 33222222222211111111110000000000
   14379                                                                      10987654321098765432109876543210
   14380                                                                      011001x110011xx0101xxxxxxxxxxxxx
   14381                                                                      fcvtzs.  */
   14382                                                                   return 1414;
   14383                                                                 }
   14384                                                             }
   14385                                                           else
   14386                                                             {
   14387                                                               if (((word >> 17) & 0x1) == 0)
   14388                                                                 {
   14389                                                                   if (((word >> 18) & 0x1) == 0)
   14390                                                                     {
   14391                                                                       /* 33222222222211111111110000000000
   14392                                                                          10987654321098765432109876543210
   14393                                                                          011001x1x1011000101xxxxxxxxxxxxx
   14394                                                                          fcvtzs.  */
   14395                                                                       return 1415;
   14396                                                                     }
   14397                                                                   else
   14398                                                                     {
   14399                                                                       if (((word >> 23) & 0x1) == 0)
   14400                                                                         {
   14401                                                                           /* 33222222222211111111110000000000
   14402                                                                              10987654321098765432109876543210
   14403                                                                              011001x101011100101xxxxxxxxxxxxx
   14404                                                                              fcvtzs.  */
   14405                                                                           return 1412;
   14406                                                                         }
   14407                                                                       else
   14408                                                                         {
   14409                                                                           /* 33222222222211111111110000000000
   14410                                                                              10987654321098765432109876543210
   14411                                                                              011001x111011100101xxxxxxxxxxxxx
   14412                                                                              fcvtzs.  */
   14413                                                                           return 1416;
   14414                                                                         }
   14415                                                                     }
   14416                                                                 }
   14417                                                               else
   14418                                                                 {
   14419                                                                   if (((word >> 18) & 0x1) == 0)
   14420                                                                     {
   14421                                                                       /* 33222222222211111111110000000000
   14422                                                                          10987654321098765432109876543210
   14423                                                                          011001x1x1011010101xxxxxxxxxxxxx
   14424                                                                          fcvtzs.  */
   14425                                                                       return 1411;
   14426                                                                     }
   14427                                                                   else
   14428                                                                     {
   14429                                                                       if (((word >> 23) & 0x1) == 0)
   14430                                                                         {
   14431                                                                           /* 33222222222211111111110000000000
   14432                                                                              10987654321098765432109876543210
   14433                                                                              011001x101011110101xxxxxxxxxxxxx
   14434                                                                              fcvtzs.  */
   14435                                                                           return 1413;
   14436                                                                         }
   14437                                                                       else
   14438                                                                         {
   14439                                                                           /* 33222222222211111111110000000000
   14440                                                                              10987654321098765432109876543210
   14441                                                                              011001x111011110101xxxxxxxxxxxxx
   14442                                                                              fcvtzs.  */
   14443                                                                           return 1417;
   14444                                                                         }
   14445                                                                     }
   14446                                                                 }
   14447                                                             }
   14448                                                         }
   14449                                                     }
   14450                                                 }
   14451                                               else
   14452                                                 {
   14453                                                   if (((word >> 17) & 0x1) == 0)
   14454                                                     {
   14455                                                       if (((word >> 18) & 0x1) == 0)
   14456                                                         {
   14457                                                           if (((word >> 19) & 0x1) == 0)
   14458                                                             {
   14459                                                               if (((word >> 20) & 0x1) == 0)
   14460                                                                 {
   14461                                                                   /* 33222222222211111111110000000000
   14462                                                                      10987654321098765432109876543210
   14463                                                                      011001x1xx000001101xxxxxxxxxxxxx
   14464                                                                      frintp.  */
   14465                                                                   return 1470;
   14466                                                                 }
   14467                                                               else
   14468                                                                 {
   14469                                                                   /* 33222222222211111111110000000000
   14470                                                                      10987654321098765432109876543210
   14471                                                                      011001x1xx010001101xxxxxxxxxxxxx
   14472                                                                      ucvtf.  */
   14473                                                                   return 1967;
   14474                                                                 }
   14475                                                             }
   14476                                                           else
   14477                                                             {
   14478                                                               if (((word >> 20) & 0x1) == 0)
   14479                                                                 {
   14480                                                                   if (((word >> 22) & 0x1) == 0)
   14481                                                                     {
   14482                                                                       /* 33222222222211111111110000000000
   14483                                                                          10987654321098765432109876543210
   14484                                                                          011001x1x0001001101xxxxxxxxxxxxx
   14485                                                                          fcvt.  */
   14486                                                                       return 1406;
   14487                                                                     }
   14488                                                                   else
   14489                                                                     {
   14490                                                                       /* 33222222222211111111110000000000
   14491                                                                          10987654321098765432109876543210
   14492                                                                          011001x1x1001001101xxxxxxxxxxxxx
   14493                                                                          fcvt.  */
   14494                                                                       return 1408;
   14495                                                                     }
   14496                                                                 }
   14497                                                               else
   14498                                                                 {
   14499                                                                   /* 33222222222211111111110000000000
   14500                                                                      10987654321098765432109876543210
   14501                                                                      011001x1xx011001101xxxxxxxxxxxxx
   14502                                                                      fcvtzu.  */
   14503                                                                   return 1422;
   14504                                                                 }
   14505                                                             }
   14506                                                         }
   14507                                                       else
   14508                                                         {
   14509                                                           if (((word >> 19) & 0x1) == 0)
   14510                                                             {
   14511                                                               if (((word >> 22) & 0x1) == 0)
   14512                                                                 {
   14513                                                                   /* 33222222222211111111110000000000
   14514                                                                      10987654321098765432109876543210
   14515                                                                      011001x1x00x0101101xxxxxxxxxxxxx
   14516                                                                      ucvtf.  */
   14517                                                                   return 1966;
   14518                                                                 }
   14519                                                               else
   14520                                                                 {
   14521                                                                   if (((word >> 23) & 0x1) == 0)
   14522                                                                     {
   14523                                                                       /* 33222222222211111111110000000000
   14524                                                                          10987654321098765432109876543210
   14525                                                                          011001x1010x0101101xxxxxxxxxxxxx
   14526                                                                          ucvtf.  */
   14527                                                                       return 1965;
   14528                                                                     }
   14529                                                                   else
   14530                                                                     {
   14531                                                                       /* 33222222222211111111110000000000
   14532                                                                          10987654321098765432109876543210
   14533                                                                          011001x1110x0101101xxxxxxxxxxxxx
   14534                                                                          ucvtf.  */
   14535                                                                       return 1969;
   14536                                                                     }
   14537                                                                 }
   14538                                                             }
   14539                                                           else
   14540                                                             {
   14541                                                               if (((word >> 20) & 0x1) == 0)
   14542                                                                 {
   14543                                                                   /* 33222222222211111111110000000000
   14544                                                                      10987654321098765432109876543210
   14545                                                                      011001x1xx001101101xxxxxxxxxxxxx
   14546                                                                      fsqrt.  */
   14547                                                                   return 1476;
   14548                                                                 }
   14549                                                               else
   14550                                                                 {
   14551                                                                   if (((word >> 22) & 0x1) == 0)
   14552                                                                     {
   14553                                                                       /* 33222222222211111111110000000000
   14554                                                                          10987654321098765432109876543210
   14555                                                                          011001x1x0011101101xxxxxxxxxxxxx
   14556                                                                          fcvtzu.  */
   14557                                                                       return 1421;
   14558                                                                     }
   14559                                                                   else
   14560                                                                     {
   14561                                                                       if (((word >> 23) & 0x1) == 0)
   14562                                                                         {
   14563                                                                           /* 33222222222211111111110000000000
   14564                                                                              10987654321098765432109876543210
   14565                                                                              011001x101011101101xxxxxxxxxxxxx
   14566                                                                              fcvtzu.  */
   14567                                                                           return 1419;
   14568                                                                         }
   14569                                                                       else
   14570                                                                         {
   14571                                                                           /* 33222222222211111111110000000000
   14572                                                                              10987654321098765432109876543210
   14573                                                                              011001x111011101101xxxxxxxxxxxxx
   14574                                                                              fcvtzu.  */
   14575                                                                           return 1423;
   14576                                                                         }
   14577                                                                     }
   14578                                                                 }
   14579                                                             }
   14580                                                         }
   14581                                                     }
   14582                                                   else
   14583                                                     {
   14584                                                       if (((word >> 18) & 0x1) == 0)
   14585                                                         {
   14586                                                           if (((word >> 19) & 0x1) == 0)
   14587                                                             {
   14588                                                               if (((word >> 20) & 0x1) == 0)
   14589                                                                 {
   14590                                                                   /* 33222222222211111111110000000000
   14591                                                                      10987654321098765432109876543210
   14592                                                                      011001x1xx000011101xxxxxxxxxxxxx
   14593                                                                      frintz.  */
   14594                                                                   return 1472;
   14595                                                                 }
   14596                                                               else
   14597                                                                 {
   14598                                                                   /* 33222222222211111111110000000000
   14599                                                                      10987654321098765432109876543210
   14600                                                                      011001x1xx010011101xxxxxxxxxxxxx
   14601                                                                      ucvtf.  */
   14602                                                                   return 1964;
   14603                                                                 }
   14604                                                             }
   14605                                                           else
   14606                                                             {
   14607                                                               if (((word >> 20) & 0x1) == 0)
   14608                                                                 {
   14609                                                                   /* 33222222222211111111110000000000
   14610                                                                      10987654321098765432109876543210
   14611                                                                      011001x1xx001011101xxxxxxxxxxxxx
   14612                                                                      fcvt.  */
   14613                                                                   return 1410;
   14614                                                                 }
   14615                                                               else
   14616                                                                 {
   14617                                                                   /* 33222222222211111111110000000000
   14618                                                                      10987654321098765432109876543210
   14619                                                                      011001x1xx011011101xxxxxxxxxxxxx
   14620                                                                      fcvtzu.  */
   14621                                                                   return 1418;
   14622                                                                 }
   14623                                                             }
   14624                                                         }
   14625                                                       else
   14626                                                         {
   14627                                                           if (((word >> 19) & 0x1) == 0)
   14628                                                             {
   14629                                                               if (((word >> 20) & 0x1) == 0)
   14630                                                                 {
   14631                                                                   /* 33222222222211111111110000000000
   14632                                                                      10987654321098765432109876543210
   14633                                                                      011001x1xx000111101xxxxxxxxxxxxx
   14634                                                                      frinti.  */
   14635                                                                   return 1467;
   14636                                                                 }
   14637                                                               else
   14638                                                                 {
   14639                                                                   if (((word >> 23) & 0x1) == 0)
   14640                                                                     {
   14641                                                                       /* 33222222222211111111110000000000
   14642                                                                          10987654321098765432109876543210
   14643                                                                          011001x10x010111101xxxxxxxxxxxxx
   14644                                                                          ucvtf.  */
   14645                                                                       return 1968;
   14646                                                                     }
   14647                                                                   else
   14648                                                                     {
   14649                                                                       /* 33222222222211111111110000000000
   14650                                                                          10987654321098765432109876543210
   14651                                                                          011001x11x010111101xxxxxxxxxxxxx
   14652                                                                          ucvtf.  */
   14653                                                                       return 1970;
   14654                                                                     }
   14655                                                                 }
   14656                                                             }
   14657                                                           else
   14658                                                             {
   14659                                                               if (((word >> 23) & 0x1) == 0)
   14660                                                                 {
   14661                                                                   /* 33222222222211111111110000000000
   14662                                                                      10987654321098765432109876543210
   14663                                                                      011001x10x0x1111101xxxxxxxxxxxxx
   14664                                                                      fcvtzu.  */
   14665                                                                   return 1420;
   14666                                                                 }
   14667                                                               else
   14668                                                                 {
   14669                                                                   /* 33222222222211111111110000000000
   14670                                                                      10987654321098765432109876543210
   14671                                                                      011001x11x0x1111101xxxxxxxxxxxxx
   14672                                                                      fcvtzu.  */
   14673                                                                   return 1424;
   14674                                                                 }
   14675                                                             }
   14676                                                         }
   14677                                                     }
   14678                                                 }
   14679                                             }
   14680                                           else
   14681                                             {
   14682                                               if (((word >> 22) & 0x1) == 0)
   14683                                                 {
   14684                                                   if (((word >> 23) & 0x1) == 0)
   14685                                                     {
   14686                                                       /* 33222222222211111111110000000000
   14687                                                          10987654321098765432109876543210
   14688                                                          111001x1000xxxxx101xxxxxxxxxxxxx
   14689                                                          st1w.  */
   14690                                                       return 1902;
   14691                                                     }
   14692                                                   else
   14693                                                     {
   14694                                                       /* 33222222222211111111110000000000
   14695                                                          10987654321098765432109876543210
   14696                                                          111001x1100xxxxx101xxxxxxxxxxxxx
   14697                                                          st1d.  */
   14698                                                       return 1881;
   14699                                                     }
   14700                                                 }
   14701                                               else
   14702                                                 {
   14703                                                   if (((word >> 23) & 0x1) == 0)
   14704                                                     {
   14705                                                       /* 33222222222211111111110000000000
   14706                                                          10987654321098765432109876543210
   14707                                                          111001x1010xxxxx101xxxxxxxxxxxxx
   14708                                                          st1w.  */
   14709                                                       return 1909;
   14710                                                     }
   14711                                                   else
   14712                                                     {
   14713                                                       /* 33222222222211111111110000000000
   14714                                                          10987654321098765432109876543210
   14715                                                          111001x1110xxxxx101xxxxxxxxxxxxx
   14716                                                          st1d.  */
   14717                                                       return 1885;
   14718                                                     }
   14719                                                 }
   14720                                             }
   14721                                         }
   14722                                       else
   14723                                         {
   14724                                           if (((word >> 31) & 0x1) == 0)
   14725                                             {
   14726                                               /* 33222222222211111111110000000000
   14727                                                  10987654321098765432109876543210
   14728                                                  011001x1xx0xxxxx111xxxxxxxxxxxxx
   14729                                                  facgt.  */
   14730                                               return 1383;
   14731                                             }
   14732                                           else
   14733                                             {
   14734                                               if (((word >> 20) & 0x1) == 0)
   14735                                                 {
   14736                                                   /* 33222222222211111111110000000000
   14737                                                      10987654321098765432109876543210
   14738                                                      111001x1xx00xxxx111xxxxxxxxxxxxx
   14739                                                      st1w.  */
   14740                                                   return 1910;
   14741                                                 }
   14742                                               else
   14743                                                 {
   14744                                                   if (((word >> 22) & 0x1) == 0)
   14745                                                     {
   14746                                                       if (((word >> 23) & 0x1) == 0)
   14747                                                         {
   14748                                                           /* 33222222222211111111110000000000
   14749                                                              10987654321098765432109876543210
   14750                                                              111001x10001xxxx111xxxxxxxxxxxxx
   14751                                                              stnt1w.  */
   14752                                                           return 1944;
   14753                                                         }
   14754                                                       else
   14755                                                         {
   14756                                                           /* 33222222222211111111110000000000
   14757                                                              10987654321098765432109876543210
   14758                                                              111001x11001xxxx111xxxxxxxxxxxxx
   14759                                                              stnt1d.  */
   14760                                                           return 1940;
   14761                                                         }
   14762                                                     }
   14763                                                   else
   14764                                                     {
   14765                                                       if (((word >> 23) & 0x1) == 0)
   14766                                                         {
   14767                                                           /* 33222222222211111111110000000000
   14768                                                              10987654321098765432109876543210
   14769                                                              111001x10101xxxx111xxxxxxxxxxxxx
   14770                                                              st3w.  */
   14771                                                           return 1928;
   14772                                                         }
   14773                                                       else
   14774                                                         {
   14775                                                           /* 33222222222211111111110000000000
   14776                                                              10987654321098765432109876543210
   14777                                                              111001x11101xxxx111xxxxxxxxxxxxx
   14778                                                              st3d.  */
   14779                                                           return 1924;
   14780                                                         }
   14781                                                     }
   14782                                                 }
   14783                                             }
   14784                                         }
   14785                                     }
   14786                                 }
   14787                             }
   14788                           else
   14789                             {
   14790                               if (((word >> 30) & 0x1) == 0)
   14791                                 {
   14792                                   if (((word >> 14) & 0x1) == 0)
   14793                                     {
   14794                                       if (((word >> 20) & 0x1) == 0)
   14795                                         {
   14796                                           if (((word >> 31) & 0x1) == 0)
   14797                                             {
   14798                                               if (((word >> 16) & 0x1) == 0)
   14799                                                 {
   14800                                                   if (((word >> 17) & 0x1) == 0)
   14801                                                     {
   14802                                                       if (((word >> 18) & 0x1) == 0)
   14803                                                         {
   14804                                                           if (((word >> 19) & 0x1) == 0)
   14805                                                             {
   14806                                                               /* 33222222222211111111110000000000
   14807                                                                  10987654321098765432109876543210
   14808                                                                  001001x1xx10000010xxxxxxxxxxxxxx
   14809                                                                  cntp.  */
   14810                                                               return 1352;
   14811                                                             }
   14812                                                           else
   14813                                                             {
   14814                                                               if (((word >> 10) & 0x1) == 0)
   14815                                                                 {
   14816                                                                   if (((word >> 11) & 0x1) == 0)
   14817                                                                     {
   14818                                                                       if (((word >> 12) & 0x1) == 0)
   14819                                                                         {
   14820                                                                           /* 33222222222211111111110000000000
   14821                                                                              10987654321098765432109876543210
   14822                                                                              001001x1xx10100010x000xxxxxxxxxx
   14823                                                                              sqincp.  */
   14824                                                                           return 1859;
   14825                                                                         }
   14826                                                                       else
   14827                                                                         {
   14828                                                                           /* 33222222222211111111110000000000
   14829                                                                              10987654321098765432109876543210
   14830                                                                              001001x1xx10100010x100xxxxxxxxxx
   14831                                                                              wrffr.  */
   14832                                                                           return 2032;
   14833                                                                         }
   14834                                                                     }
   14835                                                                   else
   14836                                                                     {
   14837                                                                       /* 33222222222211111111110000000000
   14838                                                                          10987654321098765432109876543210
   14839                                                                          001001x1xx10100010xx10xxxxxxxxxx
   14840                                                                          sqincp.  */
   14841                                                                       return 1861;
   14842                                                                     }
   14843                                                                 }
   14844                                                               else
   14845                                                                 {
   14846                                                                   /* 33222222222211111111110000000000
   14847                                                                      10987654321098765432109876543210
   14848                                                                      001001x1xx10100010xxx1xxxxxxxxxx
   14849                                                                      sqincp.  */
   14850                                                                   return 1860;
   14851                                                                 }
   14852                                                             }
   14853                                                         }
   14854                                                       else
   14855                                                         {
   14856                                                           if (((word >> 11) & 0x1) == 0)
   14857                                                             {
   14858                                                               if (((word >> 12) & 0x1) == 0)
   14859                                                                 {
   14860                                                                   /* 33222222222211111111110000000000
   14861                                                                      10987654321098765432109876543210
   14862                                                                      001001x1xx10x10010x00xxxxxxxxxxx
   14863                                                                      incp.  */
   14864                                                                   return 1490;
   14865                                                                 }
   14866                                                               else
   14867                                                                 {
   14868                                                                   /* 33222222222211111111110000000000
   14869                                                                      10987654321098765432109876543210
   14870                                                                      001001x1xx10x10010x10xxxxxxxxxxx
   14871                                                                      setffr.  */
   14872                                                                   return 1826;
   14873                                                                 }
   14874                                                             }
   14875                                                           else
   14876                                                             {
   14877                                                               /* 33222222222211111111110000000000
   14878                                                                  10987654321098765432109876543210
   14879                                                                  001001x1xx10x10010xx1xxxxxxxxxxx
   14880                                                                  incp.  */
   14881                                                               return 1491;
   14882                                                             }
   14883                                                         }
   14884                                                     }
   14885                                                   else
   14886                                                     {
   14887                                                       if (((word >> 10) & 0x1) == 0)
   14888                                                         {
   14889                                                           if (((word >> 11) & 0x1) == 0)
   14890                                                             {
   14891                                                               /* 33222222222211111111110000000000
   14892                                                                  10987654321098765432109876543210
   14893                                                                  001001x1xx10xx1010xx00xxxxxxxxxx
   14894                                                                  sqdecp.  */
   14895                                                               return 1845;
   14896                                                             }
   14897                                                           else
   14898                                                             {
   14899                                                               /* 33222222222211111111110000000000
   14900                                                                  10987654321098765432109876543210
   14901                                                                  001001x1xx10xx1010xx10xxxxxxxxxx
   14902                                                                  sqdecp.  */
   14903                                                               return 1847;
   14904                                                             }
   14905                                                         }
   14906                                                       else
   14907                                                         {
   14908                                                           /* 33222222222211111111110000000000
   14909                                                              10987654321098765432109876543210
   14910                                                              001001x1xx10xx1010xxx1xxxxxxxxxx
   14911                                                              sqdecp.  */
   14912                                                           return 1846;
   14913                                                         }
   14914                                                     }
   14915                                                 }
   14916                                               else
   14917                                                 {
   14918                                                   if (((word >> 10) & 0x1) == 0)
   14919                                                     {
   14920                                                       if (((word >> 11) & 0x1) == 0)
   14921                                                         {
   14922                                                           if (((word >> 17) & 0x1) == 0)
   14923                                                             {
   14924                                                               if (((word >> 18) & 0x1) == 0)
   14925                                                                 {
   14926                                                                   /* 33222222222211111111110000000000
   14927                                                                      10987654321098765432109876543210
   14928                                                                      001001x1xx10x00110xx00xxxxxxxxxx
   14929                                                                      uqincp.  */
   14930                                                                   return 2007;
   14931                                                                 }
   14932                                                               else
   14933                                                                 {
   14934                                                                   /* 33222222222211111111110000000000
   14935                                                                      10987654321098765432109876543210
   14936                                                                      001001x1xx10x10110xx00xxxxxxxxxx
   14937                                                                      decp.  */
   14938                                                                   return 1365;
   14939                                                                 }
   14940                                                             }
   14941                                                           else
   14942                                                             {
   14943                                                               /* 33222222222211111111110000000000
   14944                                                                  10987654321098765432109876543210
   14945                                                                  001001x1xx10xx1110xx00xxxxxxxxxx
   14946                                                                  uqdecp.  */
   14947                                                               return 1993;
   14948                                                             }
   14949                                                         }
   14950                                                       else
   14951                                                         {
   14952                                                           if (((word >> 17) & 0x1) == 0)
   14953                                                             {
   14954                                                               if (((word >> 18) & 0x1) == 0)
   14955                                                                 {
   14956                                                                   /* 33222222222211111111110000000000
   14957                                                                      10987654321098765432109876543210
   14958                                                                      001001x1xx10x00110xx10xxxxxxxxxx
   14959                                                                      uqincp.  */
   14960                                                                   return 2008;
   14961                                                                 }
   14962                                                               else
   14963                                                                 {
   14964                                                                   /* 33222222222211111111110000000000
   14965                                                                      10987654321098765432109876543210
   14966                                                                      001001x1xx10x10110xx10xxxxxxxxxx
   14967                                                                      decp.  */
   14968                                                                   return 1366;
   14969                                                                 }
   14970                                                             }
   14971                                                           else
   14972                                                             {
   14973                                                               /* 33222222222211111111110000000000
   14974                                                                  10987654321098765432109876543210
   14975                                                                  001001x1xx10xx1110xx10xxxxxxxxxx
   14976                                                                  uqdecp.  */
   14977                                                               return 1994;
   14978                                                             }
   14979                                                         }
   14980                                                     }
   14981                                                   else
   14982                                                     {
   14983                                                       if (((word >> 17) & 0x1) == 0)
   14984                                                         {
   14985                                                           /* 33222222222211111111110000000000
   14986                                                              10987654321098765432109876543210
   14987                                                              001001x1xx10xx0110xxx1xxxxxxxxxx
   14988                                                              uqincp.  */
   14989                                                           return 2009;
   14990                                                         }
   14991                                                       else
   14992                                                         {
   14993                                                           /* 33222222222211111111110000000000
   14994                                                              10987654321098765432109876543210
   14995                                                              001001x1xx10xx1110xxx1xxxxxxxxxx
   14996                                                              uqdecp.  */
   14997                                                           return 1995;
   14998                                                         }
   14999                                                     }
   15000                                                 }
   15001                                             }
   15002                                           else
   15003                                             {
   15004                                               if (((word >> 22) & 0x1) == 0)
   15005                                                 {
   15006                                                   if (((word >> 23) & 0x1) == 0)
   15007                                                     {
   15008                                                       /* 33222222222211111111110000000000
   15009                                                          10987654321098765432109876543210
   15010                                                          101001x10010xxxx10xxxxxxxxxxxxxx
   15011                                                          ld1sh.  */
   15012                                                       return 1583;
   15013                                                     }
   15014                                                   else
   15015                                                     {
   15016                                                       /* 33222222222211111111110000000000
   15017                                                          10987654321098765432109876543210
   15018                                                          101001x11010xxxx10xxxxxxxxxxxxxx
   15019                                                          ld1sb.  */
   15020                                                       return 1570;
   15021                                                     }
   15022                                                 }
   15023                                               else
   15024                                                 {
   15025                                                   if (((word >> 23) & 0x1) == 0)
   15026                                                     {
   15027                                                       /* 33222222222211111111110000000000
   15028                                                          10987654321098765432109876543210
   15029                                                          101001x10110xxxx10xxxxxxxxxxxxxx
   15030                                                          ld1w.  */
   15031                                                       return 1602;
   15032                                                     }
   15033                                                   else
   15034                                                     {
   15035                                                       /* 33222222222211111111110000000000
   15036                                                          10987654321098765432109876543210
   15037                                                          101001x11110xxxx10xxxxxxxxxxxxxx
   15038                                                          ld1d.  */
   15039                                                       return 1522;
   15040                                                     }
   15041                                                 }
   15042                                             }
   15043                                         }
   15044                                       else
   15045                                         {
   15046                                           if (((word >> 22) & 0x1) == 0)
   15047                                             {
   15048                                               if (((word >> 23) & 0x1) == 0)
   15049                                                 {
   15050                                                   /* 33222222222211111111110000000000
   15051                                                      10987654321098765432109876543210
   15052                                                      x01001x10011xxxx10xxxxxxxxxxxxxx
   15053                                                      ldnf1sh.  */
   15054                                                   return 1716;
   15055                                                 }
   15056                                               else
   15057                                                 {
   15058                                                   /* 33222222222211111111110000000000
   15059                                                      10987654321098765432109876543210
   15060                                                      x01001x11011xxxx10xxxxxxxxxxxxxx
   15061                                                      ldnf1sb.  */
   15062                                                   return 1713;
   15063                                                 }
   15064                                             }
   15065                                           else
   15066                                             {
   15067                                               if (((word >> 23) & 0x1) == 0)
   15068                                                 {
   15069                                                   /* 33222222222211111111110000000000
   15070                                                      10987654321098765432109876543210
   15071                                                      x01001x10111xxxx10xxxxxxxxxxxxxx
   15072                                                      ldnf1w.  */
   15073                                                   return 1719;
   15074                                                 }
   15075                                               else
   15076                                                 {
   15077                                                   /* 33222222222211111111110000000000
   15078                                                      10987654321098765432109876543210
   15079                                                      x01001x11111xxxx10xxxxxxxxxxxxxx
   15080                                                      ldnf1d.  */
   15081                                                   return 1708;
   15082                                                 }
   15083                                             }
   15084                                         }
   15085                                     }
   15086                                   else
   15087                                     {
   15088                                       if (((word >> 31) & 0x1) == 0)
   15089                                         {
   15090                                           if (((word >> 16) & 0x1) == 0)
   15091                                             {
   15092                                               if (((word >> 17) & 0x1) == 0)
   15093                                                 {
   15094                                                   if (((word >> 18) & 0x1) == 0)
   15095                                                     {
   15096                                                       if (((word >> 19) & 0x1) == 0)
   15097                                                         {
   15098                                                           if (((word >> 20) & 0x1) == 0)
   15099                                                             {
   15100                                                               /* 33222222222211111111110000000000
   15101                                                                  10987654321098765432109876543210
   15102                                                                  001001x1xx10000011xxxxxxxxxxxxxx
   15103                                                                  add.  */
   15104                                                               return 1279;
   15105                                                             }
   15106                                                           else
   15107                                                             {
   15108                                                               /* 33222222222211111111110000000000
   15109                                                                  10987654321098765432109876543210
   15110                                                                  001001x1xx11000011xxxxxxxxxxxxxx
   15111                                                                  mul.  */
   15112                                                               return 1748;
   15113                                                             }
   15114                                                         }
   15115                                                       else
   15116                                                         {
   15117                                                           if (((word >> 20) & 0x1) == 0)
   15118                                                             {
   15119                                                               /* 33222222222211111111110000000000
   15120                                                                  10987654321098765432109876543210
   15121                                                                  001001x1xx10100011xxxxxxxxxxxxxx
   15122                                                                  smax.  */
   15123                                                               return 1827;
   15124                                                             }
   15125                                                           else
   15126                                                             {
   15127                                                               /* 33222222222211111111110000000000
   15128                                                                  10987654321098765432109876543210
   15129                                                                  001001x1xx11100011xxxxxxxxxxxxxx
   15130                                                                  dup.  */
   15131                                                               return 1371;
   15132                                                             }
   15133                                                         }
   15134                                                     }
   15135                                                   else
   15136                                                     {
   15137                                                       /* 33222222222211111111110000000000
   15138                                                          10987654321098765432109876543210
   15139                                                          001001x1xx1xx10011xxxxxxxxxxxxxx
   15140                                                          sqadd.  */
   15141                                                       return 1836;
   15142                                                     }
   15143                                                 }
   15144                                               else
   15145                                                 {
   15146                                                   if (((word >> 18) & 0x1) == 0)
   15147                                                     {
   15148                                                       /* 33222222222211111111110000000000
   15149                                                          10987654321098765432109876543210
   15150                                                          001001x1xx1xx01011xxxxxxxxxxxxxx
   15151                                                          smin.  */
   15152                                                       return 1830;
   15153                                                     }
   15154                                                   else
   15155                                                     {
   15156                                                       /* 33222222222211111111110000000000
   15157                                                          10987654321098765432109876543210
   15158                                                          001001x1xx1xx11011xxxxxxxxxxxxxx
   15159                                                          sqsub.  */
   15160                                                       return 1866;
   15161                                                     }
   15162                                                 }
   15163                                             }
   15164                                           else
   15165                                             {
   15166                                               if (((word >> 17) & 0x1) == 0)
   15167                                                 {
   15168                                                   if (((word >> 18) & 0x1) == 0)
   15169                                                     {
   15170                                                       if (((word >> 19) & 0x1) == 0)
   15171                                                         {
   15172                                                           /* 33222222222211111111110000000000
   15173                                                              10987654321098765432109876543210
   15174                                                              001001x1xx1x000111xxxxxxxxxxxxxx
   15175                                                              sub.  */
   15176                                                           return 1948;
   15177                                                         }
   15178                                                       else
   15179                                                         {
   15180                                                           if (((word >> 20) & 0x1) == 0)
   15181                                                             {
   15182                                                               /* 33222222222211111111110000000000
   15183                                                                  10987654321098765432109876543210
   15184                                                                  001001x1xx10100111xxxxxxxxxxxxxx
   15185                                                                  umax.  */
   15186                                                               return 1976;
   15187                                                             }
   15188                                                           else
   15189                                                             {
   15190                                                               /* 33222222222211111111110000000000
   15191                                                                  10987654321098765432109876543210
   15192                                                                  001001x1xx11100111xxxxxxxxxxxxxx
   15193                                                                  fdup.  */
   15194                                                               return 1427;
   15195                                                             }
   15196                                                         }
   15197                                                     }
   15198                                                   else
   15199                                                     {
   15200                                                       /* 33222222222211111111110000000000
   15201                                                          10987654321098765432109876543210
   15202                                                          001001x1xx1xx10111xxxxxxxxxxxxxx
   15203                                                          uqadd.  */
   15204                                                       return 1984;
   15205                                                     }
   15206                                                 }
   15207                                               else
   15208                                                 {
   15209                                                   if (((word >> 18) & 0x1) == 0)
   15210                                                     {
   15211                                                       if (((word >> 19) & 0x1) == 0)
   15212                                                         {
   15213                                                           /* 33222222222211111111110000000000
   15214                                                              10987654321098765432109876543210
   15215                                                              001001x1xx1x001111xxxxxxxxxxxxxx
   15216                                                              subr.  */
   15217                                                           return 1950;
   15218                                                         }
   15219                                                       else
   15220                                                         {
   15221                                                           /* 33222222222211111111110000000000
   15222                                                              10987654321098765432109876543210
   15223                                                              001001x1xx1x101111xxxxxxxxxxxxxx
   15224                                                              umin.  */
   15225                                                           return 1979;
   15226                                                         }
   15227                                                     }
   15228                                                   else
   15229                                                     {
   15230                                                       /* 33222222222211111111110000000000
   15231                                                          10987654321098765432109876543210
   15232                                                          001001x1xx1xx11111xxxxxxxxxxxxxx
   15233                                                          uqsub.  */
   15234                                                       return 2014;
   15235                                                     }
   15236                                                 }
   15237                                             }
   15238                                         }
   15239                                       else
   15240                                         {
   15241                                           if (((word >> 13) & 0x1) == 0)
   15242                                             {
   15243                                               if (((word >> 22) & 0x1) == 0)
   15244                                                 {
   15245                                                   if (((word >> 23) & 0x1) == 0)
   15246                                                     {
   15247                                                       /* 33222222222211111111110000000000
   15248                                                          10987654321098765432109876543210
   15249                                                          101001x1001xxxxx110xxxxxxxxxxxxx
   15250                                                          ld2w.  */
   15251                                                       return 1610;
   15252                                                     }
   15253                                                   else
   15254                                                     {
   15255                                                       /* 33222222222211111111110000000000
   15256                                                          10987654321098765432109876543210
   15257                                                          101001x1101xxxxx110xxxxxxxxxxxxx
   15258                                                          ld2d.  */
   15259                                                       return 1606;
   15260                                                     }
   15261                                                 }
   15262                                               else
   15263                                                 {
   15264                                                   if (((word >> 23) & 0x1) == 0)
   15265                                                     {
   15266                                                       /* 33222222222211111111110000000000
   15267                                                          10987654321098765432109876543210
   15268                                                          101001x1011xxxxx110xxxxxxxxxxxxx
   15269                                                          ld4w.  */
   15270                                                       return 1626;
   15271                                                     }
   15272                                                   else
   15273                                                     {
   15274                                                       /* 33222222222211111111110000000000
   15275                                                          10987654321098765432109876543210
   15276                                                          101001x1111xxxxx110xxxxxxxxxxxxx
   15277                                                          ld4d.  */
   15278                                                       return 1622;
   15279                                                     }
   15280                                                 }
   15281                                             }
   15282                                           else
   15283                                             {
   15284                                               if (((word >> 22) & 0x1) == 0)
   15285                                                 {
   15286                                                   if (((word >> 23) & 0x1) == 0)
   15287                                                     {
   15288                                                       /* 33222222222211111111110000000000
   15289                                                          10987654321098765432109876543210
   15290                                                          101001x1001xxxxx111xxxxxxxxxxxxx
   15291                                                          ld2w.  */
   15292                                                       return 1611;
   15293                                                     }
   15294                                                   else
   15295                                                     {
   15296                                                       /* 33222222222211111111110000000000
   15297                                                          10987654321098765432109876543210
   15298                                                          101001x1101xxxxx111xxxxxxxxxxxxx
   15299                                                          ld2d.  */
   15300                                                       return 1607;
   15301                                                     }
   15302                                                 }
   15303                                               else
   15304                                                 {
   15305                                                   if (((word >> 23) & 0x1) == 0)
   15306                                                     {
   15307                                                       /* 33222222222211111111110000000000
   15308                                                          10987654321098765432109876543210
   15309                                                          101001x1011xxxxx111xxxxxxxxxxxxx
   15310                                                          ld4w.  */
   15311                                                       return 1627;
   15312                                                     }
   15313                                                   else
   15314                                                     {
   15315                                                       /* 33222222222211111111110000000000
   15316                                                          10987654321098765432109876543210
   15317                                                          101001x1111xxxxx111xxxxxxxxxxxxx
   15318                                                          ld4d.  */
   15319                                                       return 1623;
   15320                                                     }
   15321                                                 }
   15322                                             }
   15323                                         }
   15324                                     }
   15325                                 }
   15326                               else
   15327                                 {
   15328                                   if (((word >> 13) & 0x1) == 0)
   15329                                     {
   15330                                       if (((word >> 31) & 0x1) == 0)
   15331                                         {
   15332                                           if (((word >> 14) & 0x1) == 0)
   15333                                             {
   15334                                               /* 33222222222211111111110000000000
   15335                                                  10987654321098765432109876543210
   15336                                                  011001x1xx1xxxxx100xxxxxxxxxxxxx
   15337                                                  fmad.  */
   15338                                               return 1429;
   15339                                             }
   15340                                           else
   15341                                             {
   15342                                               /* 33222222222211111111110000000000
   15343                                                  10987654321098765432109876543210
   15344                                                  011001x1xx1xxxxx110xxxxxxxxxxxxx
   15345                                                  fnmad.  */
   15346                                               return 1459;
   15347                                             }
   15348                                         }
   15349                                       else
   15350                                         {
   15351                                           if (((word >> 22) & 0x1) == 0)
   15352                                             {
   15353                                               if (((word >> 23) & 0x1) == 0)
   15354                                                 {
   15355                                                   /* 33222222222211111111110000000000
   15356                                                      10987654321098765432109876543210
   15357                                                      111001x1001xxxxx1x0xxxxxxxxxxxxx
   15358                                                      st1w.  */
   15359                                                   return 1903;
   15360                                                 }
   15361                                               else
   15362                                                 {
   15363                                                   /* 33222222222211111111110000000000
   15364                                                      10987654321098765432109876543210
   15365                                                      111001x1101xxxxx1x0xxxxxxxxxxxxx
   15366                                                      st1d.  */
   15367                                                   return 1882;
   15368                                                 }
   15369                                             }
   15370                                           else
   15371                                             {
   15372                                               /* 33222222222211111111110000000000
   15373                                                  10987654321098765432109876543210
   15374                                                  111001x1x11xxxxx1x0xxxxxxxxxxxxx
   15375                                                  st1w.  */
   15376                                               return 1908;
   15377                                             }
   15378                                         }
   15379                                     }
   15380                                   else
   15381                                     {
   15382                                       if (((word >> 14) & 0x1) == 0)
   15383                                         {
   15384                                           if (((word >> 31) & 0x1) == 0)
   15385                                             {
   15386                                               /* 33222222222211111111110000000000
   15387                                                  10987654321098765432109876543210
   15388                                                  011001x1xx1xxxxx101xxxxxxxxxxxxx
   15389                                                  fmsb.  */
   15390                                               return 1450;
   15391                                             }
   15392                                           else
   15393                                             {
   15394                                               if (((word >> 22) & 0x1) == 0)
   15395                                                 {
   15396                                                   if (((word >> 23) & 0x1) == 0)
   15397                                                     {
   15398                                                       /* 33222222222211111111110000000000
   15399                                                          10987654321098765432109876543210
   15400                                                          111001x1001xxxxx101xxxxxxxxxxxxx
   15401                                                          st1w.  */
   15402                                                       return 1904;
   15403                                                     }
   15404                                                   else
   15405                                                     {
   15406                                                       /* 33222222222211111111110000000000
   15407                                                          10987654321098765432109876543210
   15408                                                          111001x1101xxxxx101xxxxxxxxxxxxx
   15409                                                          st1d.  */
   15410                                                       return 1883;
   15411                                                     }
   15412                                                 }
   15413                                               else
   15414                                                 {
   15415                                                   /* 33222222222211111111110000000000
   15416                                                      10987654321098765432109876543210
   15417                                                      111001x1x11xxxxx101xxxxxxxxxxxxx
   15418                                                      st1w.  */
   15419                                                   return 1911;
   15420                                                 }
   15421                                             }
   15422                                         }
   15423                                       else
   15424                                         {
   15425                                           if (((word >> 31) & 0x1) == 0)
   15426                                             {
   15427                                               /* 33222222222211111111110000000000
   15428                                                  10987654321098765432109876543210
   15429                                                  011001x1xx1xxxxx111xxxxxxxxxxxxx
   15430                                                  fnmsb.  */
   15431                                               return 1462;
   15432                                             }
   15433                                           else
   15434                                             {
   15435                                               if (((word >> 20) & 0x1) == 0)
   15436                                                 {
   15437                                                   if (((word >> 23) & 0x1) == 0)
   15438                                                     {
   15439                                                       /* 33222222222211111111110000000000
   15440                                                          10987654321098765432109876543210
   15441                                                          111001x10x10xxxx111xxxxxxxxxxxxx
   15442                                                          st1w.  */
   15443                                                       return 1912;
   15444                                                     }
   15445                                                   else
   15446                                                     {
   15447                                                       /* 33222222222211111111110000000000
   15448                                                          10987654321098765432109876543210
   15449                                                          111001x11x10xxxx111xxxxxxxxxxxxx
   15450                                                          st1d.  */
   15451                                                       return 1886;
   15452                                                     }
   15453                                                 }
   15454                                               else
   15455                                                 {
   15456                                                   if (((word >> 22) & 0x1) == 0)
   15457                                                     {
   15458                                                       if (((word >> 23) & 0x1) == 0)
   15459                                                         {
   15460                                                           /* 33222222222211111111110000000000
   15461                                                              10987654321098765432109876543210
   15462                                                              111001x10011xxxx111xxxxxxxxxxxxx
   15463                                                              st2w.  */
   15464                                                           return 1920;
   15465                                                         }
   15466                                                       else
   15467                                                         {
   15468                                                           /* 33222222222211111111110000000000
   15469                                                              10987654321098765432109876543210
   15470                                                              111001x11011xxxx111xxxxxxxxxxxxx
   15471                                                              st2d.  */
   15472                                                           return 1916;
   15473                                                         }
   15474                                                     }
   15475                                                   else
   15476                                                     {
   15477                                                       if (((word >> 23) & 0x1) == 0)
   15478                                                         {
   15479                                                           /* 33222222222211111111110000000000
   15480                                                              10987654321098765432109876543210
   15481                                                              111001x10111xxxx111xxxxxxxxxxxxx
   15482                                                              st4w.  */
   15483                                                           return 1936;
   15484                                                         }
   15485                                                       else
   15486                                                         {
   15487                                                           /* 33222222222211111111110000000000
   15488                                                              10987654321098765432109876543210
   15489                                                              111001x11111xxxx111xxxxxxxxxxxxx
   15490                                                              st4d.  */
   15491                                                           return 1932;
   15492                                                         }
   15493                                                     }
   15494                                                 }
   15495                                             }
   15496                                         }
   15497                                     }
   15498                                 }
   15499                             }
   15500                         }
   15501                     }
   15502                 }
   15503             }
   15504           else
   15505             {
   15506               if (((word >> 29) & 0x1) == 0)
   15507                 {
   15508                   if (((word >> 30) & 0x1) == 0)
   15509                     {
   15510                       if (((word >> 31) & 0x1) == 0)
   15511                         {
   15512                           /* 33222222222211111111110000000000
   15513                              10987654321098765432109876543210
   15514                              000101xxxxxxxxxxxxxxxxxxxxxxxxxx
   15515                              b.  */
   15516                           return 636;
   15517                         }
   15518                       else
   15519                         {
   15520                           /* 33222222222211111111110000000000
   15521                              10987654321098765432109876543210
   15522                              100101xxxxxxxxxxxxxxxxxxxxxxxxxx
   15523                              bl.  */
   15524                           return 637;
   15525                         }
   15526                     }
   15527                   else
   15528                     {
   15529                       if (((word >> 24) & 0x1) == 0)
   15530                         {
   15531                           if (((word >> 4) & 0x1) == 0)
   15532                             {
   15533                               if (((word >> 25) & 0x1) == 0)
   15534                                 {
   15535                                   if (((word >> 31) & 0x1) == 0)
   15536                                     {
   15537                                       /* 33222222222211111111110000000000
   15538                                          10987654321098765432109876543210
   15539                                          01010100xxxxxxxxxxxxxxxxxxx0xxxx
   15540                                          b.c.  */
   15541                                       return 657;
   15542                                     }
   15543                                   else
   15544                                     {
   15545                                       if (((word >> 0) & 0x1) == 0)
   15546                                         {
   15547                                           if (((word >> 1) & 0x1) == 0)
   15548                                             {
   15549                                               if (((word >> 21) & 0x1) == 0)
   15550                                                 {
   15551                                                   /* 33222222222211111111110000000000
   15552                                                      10987654321098765432109876543210
   15553                                                      11010100xx0xxxxxxxxxxxxxxxx0xx00
   15554                                                      hlt.  */
   15555                                                   return 753;
   15556                                                 }
   15557                                               else
   15558                                                 {
   15559                                                   if (((word >> 22) & 0x1) == 0)
   15560                                                     {
   15561                                                       /* 33222222222211111111110000000000
   15562                                                          10987654321098765432109876543210
   15563                                                          11010100x01xxxxxxxxxxxxxxxx0xx00
   15564                                                          brk.  */
   15565                                                       return 752;
   15566                                                     }
   15567                                                   else
   15568                                                     {
   15569                                                       /* 33222222222211111111110000000000
   15570                                                          10987654321098765432109876543210
   15571                                                          11010100x11xxxxxxxxxxxxxxxx0xx00
   15572                                                          tcancel.  */
   15573                                                       return 1192;
   15574                                                     }
   15575                                                 }
   15576                                             }
   15577                                           else
   15578                                             {
   15579                                               if (((word >> 21) & 0x1) == 0)
   15580                                                 {
   15581                                                   /* 33222222222211111111110000000000
   15582                                                      10987654321098765432109876543210
   15583                                                      11010100xx0xxxxxxxxxxxxxxxx0xx10
   15584                                                      hvc.  */
   15585                                                   return 750;
   15586                                                 }
   15587                                               else
   15588                                                 {
   15589                                                   /* 33222222222211111111110000000000
   15590                                                      10987654321098765432109876543210
   15591                                                      11010100xx1xxxxxxxxxxxxxxxx0xx10
   15592                                                      dcps2.  */
   15593                                                   return 756;
   15594                                                 }
   15595                                             }
   15596                                         }
   15597                                       else
   15598                                         {
   15599                                           if (((word >> 1) & 0x1) == 0)
   15600                                             {
   15601                                               if (((word >> 21) & 0x1) == 0)
   15602                                                 {
   15603                                                   /* 33222222222211111111110000000000
   15604                                                      10987654321098765432109876543210
   15605                                                      11010100xx0xxxxxxxxxxxxxxxx0xx01
   15606                                                      svc.  */
   15607                                                   return 749;
   15608                                                 }
   15609                                               else
   15610                                                 {
   15611                                                   /* 33222222222211111111110000000000
   15612                                                      10987654321098765432109876543210
   15613                                                      11010100xx1xxxxxxxxxxxxxxxx0xx01
   15614                                                      dcps1.  */
   15615                                                   return 755;
   15616                                                 }
   15617                                             }
   15618                                           else
   15619                                             {
   15620                                               if (((word >> 21) & 0x1) == 0)
   15621                                                 {
   15622                                                   /* 33222222222211111111110000000000
   15623                                                      10987654321098765432109876543210
   15624                                                      11010100xx0xxxxxxxxxxxxxxxx0xx11
   15625                                                      smc.  */
   15626                                                   return 751;
   15627                                                 }
   15628                                               else
   15629                                                 {
   15630                                                   /* 33222222222211111111110000000000
   15631                                                      10987654321098765432109876543210
   15632                                                      11010100xx1xxxxxxxxxxxxxxxx0xx11
   15633                                                      dcps3.  */
   15634                                                   return 757;
   15635                                                 }
   15636                                             }
   15637                                         }
   15638                                     }
   15639                                 }
   15640                               else
   15641                                 {
   15642                                   if (((word >> 21) & 0x1) == 0)
   15643                                     {
   15644                                       if (((word >> 22) & 0x1) == 0)
   15645                                         {
   15646                                           if (((word >> 23) & 0x1) == 0)
   15647                                             {
   15648                                               /* 33222222222211111111110000000000
   15649                                                  10987654321098765432109876543210
   15650                                                  x1010110000xxxxxxxxxxxxxxxx0xxxx
   15651                                                  br.  */
   15652                                               return 638;
   15653                                             }
   15654                                           else
   15655                                             {
   15656                                               /* 33222222222211111111110000000000
   15657                                                  10987654321098765432109876543210
   15658                                                  x1010110100xxxxxxxxxxxxxxxx0xxxx
   15659                                                  eret.  */
   15660                                               return 641;
   15661                                             }
   15662                                         }
   15663                                       else
   15664                                         {
   15665                                           /* 33222222222211111111110000000000
   15666                                              10987654321098765432109876543210
   15667                                              x1010110x10xxxxxxxxxxxxxxxx0xxxx
   15668                                              ret.  */
   15669                                           return 640;
   15670                                         }
   15671                                     }
   15672                                   else
   15673                                     {
   15674                                       if (((word >> 23) & 0x1) == 0)
   15675                                         {
   15676                                           /* 33222222222211111111110000000000
   15677                                              10987654321098765432109876543210
   15678                                              x10101100x1xxxxxxxxxxxxxxxx0xxxx
   15679                                              blr.  */
   15680                                           return 639;
   15681                                         }
   15682                                       else
   15683                                         {
   15684                                           /* 33222222222211111111110000000000
   15685                                              10987654321098765432109876543210
   15686                                              x10101101x1xxxxxxxxxxxxxxxx0xxxx
   15687                                              drps.  */
   15688                                           return 642;
   15689                                         }
   15690                                     }
   15691                                 }
   15692                             }
   15693                           else
   15694                             {
   15695                               if (((word >> 10) & 0x1) == 0)
   15696                                 {
   15697                                   if (((word >> 21) & 0x1) == 0)
   15698                                     {
   15699                                       if (((word >> 22) & 0x1) == 0)
   15700                                         {
   15701                                           if (((word >> 23) & 0x1) == 0)
   15702                                             {
   15703                                               /* 33222222222211111111110000000000
   15704                                                  10987654321098765432109876543210
   15705                                                  x10101x0000xxxxxxxxxx0xxxxx1xxxx
   15706                                                  braaz.  */
   15707                                               return 647;
   15708                                             }
   15709                                           else
   15710                                             {
   15711                                               /* 33222222222211111111110000000000
   15712                                                  10987654321098765432109876543210
   15713                                                  x10101x0100xxxxxxxxxx0xxxxx1xxxx
   15714                                                  eretaa.  */
   15715                                               return 653;
   15716                                             }
   15717                                         }
   15718                                       else
   15719                                         {
   15720                                           /* 33222222222211111111110000000000
   15721                                              10987654321098765432109876543210
   15722                                              x10101x0x10xxxxxxxxxx0xxxxx1xxxx
   15723                                              retaa.  */
   15724                                           return 651;
   15725                                         }
   15726                                     }
   15727                                   else
   15728                                     {
   15729                                       /* 33222222222211111111110000000000
   15730                                          10987654321098765432109876543210
   15731                                          x10101x0xx1xxxxxxxxxx0xxxxx1xxxx
   15732                                          blraaz.  */
   15733                                       return 649;
   15734                                     }
   15735                                 }
   15736                               else
   15737                                 {
   15738                                   if (((word >> 21) & 0x1) == 0)
   15739                                     {
   15740                                       if (((word >> 22) & 0x1) == 0)
   15741                                         {
   15742                                           if (((word >> 23) & 0x1) == 0)
   15743                                             {
   15744                                               /* 33222222222211111111110000000000
   15745                                                  10987654321098765432109876543210
   15746                                                  x10101x0000xxxxxxxxxx1xxxxx1xxxx
   15747                                                  brabz.  */
   15748                                               return 648;
   15749                                             }
   15750                                           else
   15751                                             {
   15752                                               /* 33222222222211111111110000000000
   15753                                                  10987654321098765432109876543210
   15754                                                  x10101x0100xxxxxxxxxx1xxxxx1xxxx
   15755                                                  eretab.  */
   15756                                               return 654;
   15757                                             }
   15758                                         }
   15759                                       else
   15760                                         {
   15761                                           /* 33222222222211111111110000000000
   15762                                              10987654321098765432109876543210
   15763                                              x10101x0x10xxxxxxxxxx1xxxxx1xxxx
   15764                                              retab.  */
   15765                                           return 652;
   15766                                         }
   15767                                     }
   15768                                   else
   15769                                     {
   15770                                       /* 33222222222211111111110000000000
   15771                                          10987654321098765432109876543210
   15772                                          x10101x0xx1xxxxxxxxxx1xxxxx1xxxx
   15773                                          blrabz.  */
   15774                                       return 650;
   15775                                     }
   15776                                 }
   15777                             }
   15778                         }
   15779                       else
   15780                         {
   15781                           if (((word >> 21) & 0x1) == 0)
   15782                             {
   15783                               if (((word >> 25) & 0x1) == 0)
   15784                                 {
   15785                                   /* 33222222222211111111110000000000
   15786                                      10987654321098765432109876543210
   15787                                      x1010101xx0xxxxxxxxxxxxxxxxxxxxx
   15788                                      xaflag.  */
   15789                                   return 811;
   15790                                 }
   15791                               else
   15792                                 {
   15793                                   if (((word >> 10) & 0x1) == 0)
   15794                                     {
   15795                                       /* 33222222222211111111110000000000
   15796                                          10987654321098765432109876543210
   15797                                          x1010111xx0xxxxxxxxxx0xxxxxxxxxx
   15798                                          braa.  */
   15799                                       return 643;
   15800                                     }
   15801                                   else
   15802                                     {
   15803                                       /* 33222222222211111111110000000000
   15804                                          10987654321098765432109876543210
   15805                                          x1010111xx0xxxxxxxxxx1xxxxxxxxxx
   15806                                          brab.  */
   15807                                       return 644;
   15808                                     }
   15809                                 }
   15810                             }
   15811                           else
   15812                             {
   15813                               if (((word >> 25) & 0x1) == 0)
   15814                                 {
   15815                                   /* 33222222222211111111110000000000
   15816                                      10987654321098765432109876543210
   15817                                      x1010101xx1xxxxxxxxxxxxxxxxxxxxx
   15818                                      tstart.  */
   15819                                   return 1189;
   15820                                 }
   15821                               else
   15822                                 {
   15823                                   if (((word >> 10) & 0x1) == 0)
   15824                                     {
   15825                                       /* 33222222222211111111110000000000
   15826                                          10987654321098765432109876543210
   15827                                          x1010111xx1xxxxxxxxxx0xxxxxxxxxx
   15828                                          blraa.  */
   15829                                       return 645;
   15830                                     }
   15831                                   else
   15832                                     {
   15833                                       /* 33222222222211111111110000000000
   15834                                          10987654321098765432109876543210
   15835                                          x1010111xx1xxxxxxxxxx1xxxxxxxxxx
   15836                                          blrab.  */
   15837                                       return 646;
   15838                                     }
   15839                                 }
   15840                             }
   15841                         }
   15842                     }
   15843                 }
   15844               else
   15845                 {
   15846                   if (((word >> 24) & 0x1) == 0)
   15847                     {
   15848                       if (((word >> 25) & 0x1) == 0)
   15849                         {
   15850                           /* 33222222222211111111110000000000
   15851                              10987654321098765432109876543210
   15852                              xx110100xxxxxxxxxxxxxxxxxxxxxxxx
   15853                              cbz.  */
   15854                           return 655;
   15855                         }
   15856                       else
   15857                         {
   15858                           /* 33222222222211111111110000000000
   15859                              10987654321098765432109876543210
   15860                              xx110110xxxxxxxxxxxxxxxxxxxxxxxx
   15861                              tbz.  */
   15862                           return 1240;
   15863                         }
   15864                     }
   15865                   else
   15866                     {
   15867                       if (((word >> 25) & 0x1) == 0)
   15868                         {
   15869                           /* 33222222222211111111110000000000
   15870                              10987654321098765432109876543210
   15871                              xx110101xxxxxxxxxxxxxxxxxxxxxxxx
   15872                              cbnz.  */
   15873                           return 656;
   15874                         }
   15875                       else
   15876                         {
   15877                           /* 33222222222211111111110000000000
   15878                              10987654321098765432109876543210
   15879                              xx110111xxxxxxxxxxxxxxxxxxxxxxxx
   15880                              tbnz.  */
   15881                           return 1241;
   15882                         }
   15883                     }
   15884                 }
   15885             }
   15886         }
   15887       else
   15888         {
   15889           if (((word >> 25) & 0x1) == 0)
   15890             {
   15891               if (((word >> 28) & 0x1) == 0)
   15892                 {
   15893                   if (((word >> 22) & 0x1) == 0)
   15894                     {
   15895                       if (((word >> 23) & 0x1) == 0)
   15896                         {
   15897                           if (((word >> 24) & 0x1) == 0)
   15898                             {
   15899                               if (((word >> 29) & 0x1) == 0)
   15900                                 {
   15901                                   /* 33222222222211111111110000000000
   15902                                      10987654321098765432109876543210
   15903                                      xx00110000xxxxxxxxxxxxxxxxxxxxxx
   15904                                      st4.  */
   15905                                   return 440;
   15906                                 }
   15907                               else
   15908                                 {
   15909                                   /* 33222222222211111111110000000000
   15910                                      10987654321098765432109876543210
   15911                                      xx10110000xxxxxxxxxxxxxxxxxxxxxx
   15912                                      stnp.  */
   15913                                   return 973;
   15914                                 }
   15915                             }
   15916                           else
   15917                             {
   15918                               if (((word >> 29) & 0x1) == 0)
   15919                                 {
   15920                                   if (((word >> 13) & 0x1) == 0)
   15921                                     {
   15922                                       if (((word >> 21) & 0x1) == 0)
   15923                                         {
   15924                                           /* 33222222222211111111110000000000
   15925                                              10987654321098765432109876543210
   15926                                              xx001101000xxxxxxx0xxxxxxxxxxxxx
   15927                                              st1.  */
   15928                                           return 456;
   15929                                         }
   15930                                       else
   15931                                         {
   15932                                           /* 33222222222211111111110000000000
   15933                                              10987654321098765432109876543210
   15934                                              xx001101001xxxxxxx0xxxxxxxxxxxxx
   15935                                              st2.  */
   15936                                           return 458;
   15937                                         }
   15938                                     }
   15939                                   else
   15940                                     {
   15941                                       if (((word >> 21) & 0x1) == 0)
   15942                                         {
   15943                                           /* 33222222222211111111110000000000
   15944                                              10987654321098765432109876543210
   15945                                              xx001101000xxxxxxx1xxxxxxxxxxxxx
   15946                                              st3.  */
   15947                                           return 457;
   15948                                         }
   15949                                       else
   15950                                         {
   15951                                           /* 33222222222211111111110000000000
   15952                                              10987654321098765432109876543210
   15953                                              xx001101001xxxxxxx1xxxxxxxxxxxxx
   15954                                              st4.  */
   15955                                           return 459;
   15956                                         }
   15957                                     }
   15958                                 }
   15959                               else
   15960                                 {
   15961                                   /* 33222222222211111111110000000000
   15962                                      10987654321098765432109876543210
   15963                                      xx10110100xxxxxxxxxxxxxxxxxxxxxx
   15964                                      stp.  */
   15965                                   return 977;
   15966                                 }
   15967                             }
   15968                         }
   15969                       else
   15970                         {
   15971                           if (((word >> 29) & 0x1) == 0)
   15972                             {
   15973                               if (((word >> 21) & 0x1) == 0)
   15974                                 {
   15975                                   if (((word >> 24) & 0x1) == 0)
   15976                                     {
   15977                                       /* 33222222222211111111110000000000
   15978                                          10987654321098765432109876543210
   15979                                          xx001100100xxxxxxxxxxxxxxxxxxxxx
   15980                                          st4.  */
   15981                                       return 448;
   15982                                     }
   15983                                   else
   15984                                     {
   15985                                       if (((word >> 13) & 0x1) == 0)
   15986                                         {
   15987                                           /* 33222222222211111111110000000000
   15988                                              10987654321098765432109876543210
   15989                                              xx001101100xxxxxxx0xxxxxxxxxxxxx
   15990                                              st1.  */
   15991                                           return 468;
   15992                                         }
   15993                                       else
   15994                                         {
   15995                                           /* 33222222222211111111110000000000
   15996                                              10987654321098765432109876543210
   15997                                              xx001101100xxxxxxx1xxxxxxxxxxxxx
   15998                                              st3.  */
   15999                                           return 469;
   16000                                         }
   16001                                     }
   16002                                 }
   16003                               else
   16004                                 {
   16005                                   if (((word >> 13) & 0x1) == 0)
   16006                                     {
   16007                                       /* 33222222222211111111110000000000
   16008                                          10987654321098765432109876543210
   16009                                          xx00110x101xxxxxxx0xxxxxxxxxxxxx
   16010                                          st2.  */
   16011                                       return 470;
   16012                                     }
   16013                                   else
   16014                                     {
   16015                                       /* 33222222222211111111110000000000
   16016                                          10987654321098765432109876543210
   16017                                          xx00110x101xxxxxxx1xxxxxxxxxxxxx
   16018                                          st4.  */
   16019                                       return 471;
   16020                                     }
   16021                                 }
   16022                             }
   16023                           else
   16024                             {
   16025                               /* 33222222222211111111110000000000
   16026                                  10987654321098765432109876543210
   16027                                  xx10110x10xxxxxxxxxxxxxxxxxxxxxx
   16028                                  stp.  */
   16029                               return 983;
   16030                             }
   16031                         }
   16032                     }
   16033                   else
   16034                     {
   16035                       if (((word >> 23) & 0x1) == 0)
   16036                         {
   16037                           if (((word >> 24) & 0x1) == 0)
   16038                             {
   16039                               if (((word >> 29) & 0x1) == 0)
   16040                                 {
   16041                                   /* 33222222222211111111110000000000
   16042                                      10987654321098765432109876543210
   16043                                      xx00110001xxxxxxxxxxxxxxxxxxxxxx
   16044                                      ld4.  */
   16045                                   return 444;
   16046                                 }
   16047                               else
   16048                                 {
   16049                                   /* 33222222222211111111110000000000
   16050                                      10987654321098765432109876543210
   16051                                      xx10110001xxxxxxxxxxxxxxxxxxxxxx
   16052                                      ldnp.  */
   16053                                   return 974;
   16054                                 }
   16055                             }
   16056                           else
   16057                             {
   16058                               if (((word >> 29) & 0x1) == 0)
   16059                                 {
   16060                                   if (((word >> 13) & 0x1) == 0)
   16061                                     {
   16062                                       if (((word >> 21) & 0x1) == 0)
   16063                                         {
   16064                                           /* 33222222222211111111110000000000
   16065                                              10987654321098765432109876543210
   16066                                              xx001101010xxxxxxx0xxxxxxxxxxxxx
   16067                                              ld1.  */
   16068                                           return 460;
   16069                                         }
   16070                                       else
   16071                                         {
   16072                                           /* 33222222222211111111110000000000
   16073                                              10987654321098765432109876543210
   16074                                              xx001101011xxxxxxx0xxxxxxxxxxxxx
   16075                                              ld2.  */
   16076                                           return 464;
   16077                                         }
   16078                                     }
   16079                                   else
   16080                                     {
   16081                                       if (((word >> 21) & 0x1) == 0)
   16082                                         {
   16083                                           /* 33222222222211111111110000000000
   16084                                              10987654321098765432109876543210
   16085                                              xx001101010xxxxxxx1xxxxxxxxxxxxx
   16086                                              ld3.  */
   16087                                           return 461;
   16088                                         }
   16089                                       else
   16090                                         {
   16091                                           /* 33222222222211111111110000000000
   16092                                              10987654321098765432109876543210
   16093                                              xx001101011xxxxxxx1xxxxxxxxxxxxx
   16094                                              ld4.  */
   16095                                           return 465;
   16096                                         }
   16097                                     }
   16098                                 }
   16099                               else
   16100                                 {
   16101                                   /* 33222222222211111111110000000000
   16102                                      10987654321098765432109876543210
   16103                                      xx10110101xxxxxxxxxxxxxxxxxxxxxx
   16104                                      ldp.  */
   16105                                   return 978;
   16106                                 }
   16107                             }
   16108                         }
   16109                       else
   16110                         {
   16111                           if (((word >> 29) & 0x1) == 0)
   16112                             {
   16113                               if (((word >> 21) & 0x1) == 0)
   16114                                 {
   16115                                   if (((word >> 24) & 0x1) == 0)
   16116                                     {
   16117                                       /* 33222222222211111111110000000000
   16118                                          10987654321098765432109876543210
   16119                                          xx001100110xxxxxxxxxxxxxxxxxxxxx
   16120                                          ld4.  */
   16121                                       return 452;
   16122                                     }
   16123                                   else
   16124                                     {
   16125                                       if (((word >> 13) & 0x1) == 0)
   16126                                         {
   16127                                           /* 33222222222211111111110000000000
   16128                                              10987654321098765432109876543210
   16129                                              xx001101110xxxxxxx0xxxxxxxxxxxxx
   16130                                              ld1.  */
   16131                                           return 472;
   16132                                         }
   16133                                       else
   16134                                         {
   16135                                           /* 33222222222211111111110000000000
   16136                                              10987654321098765432109876543210
   16137                                              xx001101110xxxxxxx1xxxxxxxxxxxxx
   16138                                              ld3.  */
   16139                                           return 473;
   16140                                         }
   16141                                     }
   16142                                 }
   16143                               else
   16144                                 {
   16145                                   if (((word >> 13) & 0x1) == 0)
   16146                                     {
   16147                                       /* 33222222222211111111110000000000
   16148                                          10987654321098765432109876543210
   16149                                          xx00110x111xxxxxxx0xxxxxxxxxxxxx
   16150                                          ld2.  */
   16151                                       return 476;
   16152                                     }
   16153                                   else
   16154                                     {
   16155                                       /* 33222222222211111111110000000000
   16156                                          10987654321098765432109876543210
   16157                                          xx00110x111xxxxxxx1xxxxxxxxxxxxx
   16158                                          ld4.  */
   16159                                       return 477;
   16160                                     }
   16161                                 }
   16162                             }
   16163                           else
   16164                             {
   16165                               /* 33222222222211111111110000000000
   16166                                  10987654321098765432109876543210
   16167                                  xx10110x11xxxxxxxxxxxxxxxxxxxxxx
   16168                                  ldp.  */
   16169                               return 984;
   16170                             }
   16171                         }
   16172                     }
   16173                 }
   16174               else
   16175                 {
   16176                   if (((word >> 24) & 0x1) == 0)
   16177                     {
   16178                       if (((word >> 29) & 0x1) == 0)
   16179                         {
   16180                           /* 33222222222211111111110000000000
   16181                              10987654321098765432109876543210
   16182                              xx011100xxxxxxxxxxxxxxxxxxxxxxxx
   16183                              ldr.  */
   16184                           return 988;
   16185                         }
   16186                       else
   16187                         {
   16188                           if (((word >> 10) & 0x1) == 0)
   16189                             {
   16190                               if (((word >> 11) & 0x1) == 0)
   16191                                 {
   16192                                   if (((word >> 22) & 0x1) == 0)
   16193                                     {
   16194                                       /* 33222222222211111111110000000000
   16195                                          10987654321098765432109876543210
   16196                                          xx111100x0xxxxxxxxxx00xxxxxxxxxx
   16197                                          stur.  */
   16198                                       return 925;
   16199                                     }
   16200                                   else
   16201                                     {
   16202                                       /* 33222222222211111111110000000000
   16203                                          10987654321098765432109876543210
   16204                                          xx111100x1xxxxxxxxxx00xxxxxxxxxx
   16205                                          ldur.  */
   16206                                       return 926;
   16207                                     }
   16208                                 }
   16209                               else
   16210                                 {
   16211                                   if (((word >> 22) & 0x1) == 0)
   16212                                     {
   16213                                       /* 33222222222211111111110000000000
   16214                                          10987654321098765432109876543210
   16215                                          xx111100x0xxxxxxxxxx10xxxxxxxxxx
   16216                                          str.  */
   16217                                       return 904;
   16218                                     }
   16219                                   else
   16220                                     {
   16221                                       /* 33222222222211111111110000000000
   16222                                          10987654321098765432109876543210
   16223                                          xx111100x1xxxxxxxxxx10xxxxxxxxxx
   16224                                          ldr.  */
   16225                                       return 905;
   16226                                     }
   16227                                 }
   16228                             }
   16229                           else
   16230                             {
   16231                               if (((word >> 22) & 0x1) == 0)
   16232                                 {
   16233                                   /* 33222222222211111111110000000000
   16234                                      10987654321098765432109876543210
   16235                                      xx111100x0xxxxxxxxxxx1xxxxxxxxxx
   16236                                      str.  */
   16237                                   return 873;
   16238                                 }
   16239                               else
   16240                                 {
   16241                                   /* 33222222222211111111110000000000
   16242                                      10987654321098765432109876543210
   16243                                      xx111100x1xxxxxxxxxxx1xxxxxxxxxx
   16244                                      ldr.  */
   16245                                   return 874;
   16246                                 }
   16247                             }
   16248                         }
   16249                     }
   16250                   else
   16251                     {
   16252                       if (((word >> 22) & 0x1) == 0)
   16253                         {
   16254                           /* 33222222222211111111110000000000
   16255                              10987654321098765432109876543210
   16256                              xxx11101x0xxxxxxxxxxxxxxxxxxxxxx
   16257                              str.  */
   16258                           return 892;
   16259                         }
   16260                       else
   16261                         {
   16262                           /* 33222222222211111111110000000000
   16263                              10987654321098765432109876543210
   16264                              xxx11101x1xxxxxxxxxxxxxxxxxxxxxx
   16265                              ldr.  */
   16266                           return 893;
   16267                         }
   16268                     }
   16269                 }
   16270             }
   16271           else
   16272             {
   16273               if (((word >> 24) & 0x1) == 0)
   16274                 {
   16275                   if (((word >> 21) & 0x1) == 0)
   16276                     {
   16277                       if (((word >> 28) & 0x1) == 0)
   16278                         {
   16279                           if (((word >> 29) & 0x1) == 0)
   16280                             {
   16281                               if (((word >> 31) & 0x1) == 0)
   16282                                 {
   16283                                   if (((word >> 10) & 0x1) == 0)
   16284                                     {
   16285                                       if (((word >> 11) & 0x1) == 0)
   16286                                         {
   16287                                           if (((word >> 12) & 0x1) == 0)
   16288                                             {
   16289                                               /* 33222222222211111111110000000000
   16290                                                  10987654321098765432109876543210
   16291                                                  0x001110xx0xxxxxxxx000xxxxxxxxxx
   16292                                                  tbl.  */
   16293                                               return 420;
   16294                                             }
   16295                                           else
   16296                                             {
   16297                                               /* 33222222222211111111110000000000
   16298                                                  10987654321098765432109876543210
   16299                                                  0x001110xx0xxxxxxxx100xxxxxxxxxx
   16300                                                  tbx.  */
   16301                                               return 421;
   16302                                             }
   16303                                         }
   16304                                       else
   16305                                         {
   16306                                           if (((word >> 12) & 0x1) == 0)
   16307                                             {
   16308                                               if (((word >> 14) & 0x1) == 0)
   16309                                                 {
   16310                                                   /* 33222222222211111111110000000000
   16311                                                      10987654321098765432109876543210
   16312                                                      0x001110xx0xxxxxx0x010xxxxxxxxxx
   16313                                                      trn1.  */
   16314                                                   return 263;
   16315                                                 }
   16316                                               else
   16317                                                 {
   16318                                                   /* 33222222222211111111110000000000
   16319                                                      10987654321098765432109876543210
   16320                                                      0x001110xx0xxxxxx1x010xxxxxxxxxx
   16321                                                      trn2.  */
   16322                                                   return 266;
   16323                                                 }
   16324                                             }
   16325                                           else
   16326                                             {
   16327                                               if (((word >> 13) & 0x1) == 0)
   16328                                                 {
   16329                                                   if (((word >> 14) & 0x1) == 0)
   16330                                                     {
   16331                                                       /* 33222222222211111111110000000000
   16332                                                          10987654321098765432109876543210
   16333                                                          0x001110xx0xxxxxx00110xxxxxxxxxx
   16334                                                          uzp1.  */
   16335                                                       return 262;
   16336                                                     }
   16337                                                   else
   16338                                                     {
   16339                                                       /* 33222222222211111111110000000000
   16340                                                          10987654321098765432109876543210
   16341                                                          0x001110xx0xxxxxx10110xxxxxxxxxx
   16342                                                          uzp2.  */
   16343                                                       return 265;
   16344                                                     }
   16345                                                 }
   16346                                               else
   16347                                                 {
   16348                                                   if (((word >> 14) & 0x1) == 0)
   16349                                                     {
   16350                                                       /* 33222222222211111111110000000000
   16351                                                          10987654321098765432109876543210
   16352                                                          0x001110xx0xxxxxx01110xxxxxxxxxx
   16353                                                          zip1.  */
   16354                                                       return 264;
   16355                                                     }
   16356                                                   else
   16357                                                     {
   16358                                                       /* 33222222222211111111110000000000
   16359                                                          10987654321098765432109876543210
   16360                                                          0x001110xx0xxxxxx11110xxxxxxxxxx
   16361                                                          zip2.  */
   16362                                                       return 267;
   16363                                                     }
   16364                                                 }
   16365                                             }
   16366                                         }
   16367                                     }
   16368                                   else
   16369                                     {
   16370                                       if (((word >> 11) & 0x1) == 0)
   16371                                         {
   16372                                           if (((word >> 12) & 0x1) == 0)
   16373                                             {
   16374                                               if (((word >> 13) & 0x1) == 0)
   16375                                                 {
   16376                                                   if (((word >> 22) & 0x1) == 0)
   16377                                                     {
   16378                                                       /* 33222222222211111111110000000000
   16379                                                          10987654321098765432109876543210
   16380                                                          0x001110x00xxxxxxx0001xxxxxxxxxx
   16381                                                          dup.  */
   16382                                                       return 149;
   16383                                                     }
   16384                                                   else
   16385                                                     {
   16386                                                       if (((word >> 23) & 0x1) == 0)
   16387                                                         {
   16388                                                           /* 33222222222211111111110000000000
   16389                                                              10987654321098765432109876543210
   16390                                                              0x001110010xxxxxxx0001xxxxxxxxxx
   16391                                                              fmaxnm.  */
   16392                                                           return 292;
   16393                                                         }
   16394                                                       else
   16395                                                         {
   16396                                                           /* 33222222222211111111110000000000
   16397                                                              10987654321098765432109876543210
   16398                                                              0x001110110xxxxxxx0001xxxxxxxxxx
   16399                                                              fminnm.  */
   16400                                                           return 308;
   16401                                                         }
   16402                                                     }
   16403                                                 }
   16404                                               else
   16405                                                 {
   16406                                                   if (((word >> 15) & 0x1) == 0)
   16407                                                     {
   16408                                                       /* 33222222222211111111110000000000
   16409                                                          10987654321098765432109876543210
   16410                                                          0x001110xx0xxxxx0x1001xxxxxxxxxx
   16411                                                          fcmeq.  */
   16412                                                       return 300;
   16413                                                     }
   16414                                                   else
   16415                                                     {
   16416                                                       /* 33222222222211111111110000000000
   16417                                                          10987654321098765432109876543210
   16418                                                          0x001110xx0xxxxx1x1001xxxxxxxxxx
   16419                                                          smmla.  */
   16420                                                       return 2416;
   16421                                                     }
   16422                                                 }
   16423                                             }
   16424                                           else
   16425                                             {
   16426                                               if (((word >> 13) & 0x1) == 0)
   16427                                                 {
   16428                                                   if (((word >> 15) & 0x1) == 0)
   16429                                                     {
   16430                                                       if (((word >> 23) & 0x1) == 0)
   16431                                                         {
   16432                                                           /* 33222222222211111111110000000000
   16433                                                              10987654321098765432109876543210
   16434                                                              0x0011100x0xxxxx0x0101xxxxxxxxxx
   16435                                                              fadd.  */
   16436                                                           return 296;
   16437                                                         }
   16438                                                       else
   16439                                                         {
   16440                                                           /* 33222222222211111111110000000000
   16441                                                              10987654321098765432109876543210
   16442                                                              0x0011101x0xxxxx0x0101xxxxxxxxxx
   16443                                                              fsub.  */
   16444                                                           return 312;
   16445                                                         }
   16446                                                     }
   16447                                                   else
   16448                                                     {
   16449                                                       /* 33222222222211111111110000000000
   16450                                                          10987654321098765432109876543210
   16451                                                          0x001110xx0xxxxx1x0101xxxxxxxxxx
   16452                                                          sdot.  */
   16453                                                       return 2342;
   16454                                                     }
   16455                                                 }
   16456                                               else
   16457                                                 {
   16458                                                   if (((word >> 23) & 0x1) == 0)
   16459                                                     {
   16460                                                       /* 33222222222211111111110000000000
   16461                                                          10987654321098765432109876543210
   16462                                                          0x0011100x0xxxxxxx1101xxxxxxxxxx
   16463                                                          fmax.  */
   16464                                                       return 302;
   16465                                                     }
   16466                                                   else
   16467                                                     {
   16468                                                       /* 33222222222211111111110000000000
   16469                                                          10987654321098765432109876543210
   16470                                                          0x0011101x0xxxxxxx1101xxxxxxxxxx
   16471                                                          fmin.  */
   16472                                                       return 314;
   16473                                                     }
   16474                                                 }
   16475                                             }
   16476                                         }
   16477                                       else
   16478                                         {
   16479                                           if (((word >> 12) & 0x1) == 0)
   16480                                             {
   16481                                               if (((word >> 13) & 0x1) == 0)
   16482                                                 {
   16483                                                   if (((word >> 22) & 0x1) == 0)
   16484                                                     {
   16485                                                       /* 33222222222211111111110000000000
   16486                                                          10987654321098765432109876543210
   16487                                                          0x001110x00xxxxxxx0011xxxxxxxxxx
   16488                                                          dup.  */
   16489                                                       return 150;
   16490                                                     }
   16491                                                   else
   16492                                                     {
   16493                                                       if (((word >> 23) & 0x1) == 0)
   16494                                                         {
   16495                                                           /* 33222222222211111111110000000000
   16496                                                              10987654321098765432109876543210
   16497                                                              0x001110010xxxxxxx0011xxxxxxxxxx
   16498                                                              fmla.  */
   16499                                                           return 294;
   16500                                                         }
   16501                                                       else
   16502                                                         {
   16503                                                           /* 33222222222211111111110000000000
   16504                                                              10987654321098765432109876543210
   16505                                                              0x001110110xxxxxxx0011xxxxxxxxxx
   16506                                                              fmls.  */
   16507                                                           return 310;
   16508                                                         }
   16509                                                     }
   16510                                                 }
   16511                                               else
   16512                                                 {
   16513                                                   if (((word >> 15) & 0x1) == 0)
   16514                                                     {
   16515                                                       /* 33222222222211111111110000000000
   16516                                                          10987654321098765432109876543210
   16517                                                          0x001110xx0xxxxx0x1011xxxxxxxxxx
   16518                                                          smov.  */
   16519                                                       return 151;
   16520                                                     }
   16521                                                   else
   16522                                                     {
   16523                                                       /* 33222222222211111111110000000000
   16524                                                          10987654321098765432109876543210
   16525                                                          0x001110xx0xxxxx1x1011xxxxxxxxxx
   16526                                                          usmmla.  */
   16527                                                       return 2418;
   16528                                                     }
   16529                                                 }
   16530                                             }
   16531                                           else
   16532                                             {
   16533                                               if (((word >> 13) & 0x1) == 0)
   16534                                                 {
   16535                                                   if (((word >> 15) & 0x1) == 0)
   16536                                                     {
   16537                                                       if (((word >> 22) & 0x1) == 0)
   16538                                                         {
   16539                                                           /* 33222222222211111111110000000000
   16540                                                              10987654321098765432109876543210
   16541                                                              0x001110x00xxxxx0x0111xxxxxxxxxx
   16542                                                              ins.  */
   16543                                                           return 154;
   16544                                                         }
   16545                                                       else
   16546                                                         {
   16547                                                           /* 33222222222211111111110000000000
   16548                                                              10987654321098765432109876543210
   16549                                                              0x001110x10xxxxx0x0111xxxxxxxxxx
   16550                                                              fmulx.  */
   16551                                                           return 298;
   16552                                                         }
   16553                                                     }
   16554                                                   else
   16555                                                     {
   16556                                                       /* 33222222222211111111110000000000
   16557                                                          10987654321098765432109876543210
   16558                                                          0x001110xx0xxxxx1x0111xxxxxxxxxx
   16559                                                          usdot.  */
   16560                                                       return 2419;
   16561                                                     }
   16562                                                 }
   16563                                               else
   16564                                                 {
   16565                                                   if (((word >> 22) & 0x1) == 0)
   16566                                                     {
   16567                                                       /* 33222222222211111111110000000000
   16568                                                          10987654321098765432109876543210
   16569                                                          0x001110x00xxxxxxx1111xxxxxxxxxx
   16570                                                          umov.  */
   16571                                                       return 152;
   16572                                                     }
   16573                                                   else
   16574                                                     {
   16575                                                       if (((word >> 23) & 0x1) == 0)
   16576                                                         {
   16577                                                           /* 33222222222211111111110000000000
   16578                                                              10987654321098765432109876543210
   16579                                                              0x001110010xxxxxxx1111xxxxxxxxxx
   16580                                                              frecps.  */
   16581                                                           return 304;
   16582                                                         }
   16583                                                       else
   16584                                                         {
   16585                                                           /* 33222222222211111111110000000000
   16586                                                              10987654321098765432109876543210
   16587                                                              0x001110110xxxxxxx1111xxxxxxxxxx
   16588                                                              frsqrts.  */
   16589                                                           return 316;
   16590                                                         }
   16591                                                     }
   16592                                                 }
   16593                                             }
   16594                                         }
   16595                                     }
   16596                                 }
   16597                               else
   16598                                 {
   16599                                   if (((word >> 22) & 0x1) == 0)
   16600                                     {
   16601                                       if (((word >> 23) & 0x1) == 0)
   16602                                         {
   16603                                           /* 33222222222211111111110000000000
   16604                                              10987654321098765432109876543210
   16605                                              1x001110000xxxxxxxxxxxxxxxxxxxxx
   16606                                              eor3.  */
   16607                                           return 2349;
   16608                                         }
   16609                                       else
   16610                                         {
   16611                                           /* 33222222222211111111110000000000
   16612                                              10987654321098765432109876543210
   16613                                              1x001110100xxxxxxxxxxxxxxxxxxxxx
   16614                                              xar.  */
   16615                                           return 2351;
   16616                                         }
   16617                                     }
   16618                                   else
   16619                                     {
   16620                                       if (((word >> 15) & 0x1) == 0)
   16621                                         {
   16622                                           /* 33222222222211111111110000000000
   16623                                              10987654321098765432109876543210
   16624                                              1x001110x10xxxxx0xxxxxxxxxxxxxxx
   16625                                              sm3ss1.  */
   16626                                           return 2353;
   16627                                         }
   16628                                       else
   16629                                         {
   16630                                           if (((word >> 10) & 0x1) == 0)
   16631                                             {
   16632                                               if (((word >> 11) & 0x1) == 0)
   16633                                                 {
   16634                                                   if (((word >> 23) & 0x1) == 0)
   16635                                                     {
   16636                                                       /* 33222222222211111111110000000000
   16637                                                          10987654321098765432109876543210
   16638                                                          1x001110010xxxxx1xxx00xxxxxxxxxx
   16639                                                          sm3tt1a.  */
   16640                                                       return 2354;
   16641                                                     }
   16642                                                   else
   16643                                                     {
   16644                                                       /* 33222222222211111111110000000000
   16645                                                          10987654321098765432109876543210
   16646                                                          1x001110110xxxxx1xxx00xxxxxxxxxx
   16647                                                          sha512su0.  */
   16648                                                       return 2347;
   16649                                                     }
   16650                                                 }
   16651                                               else
   16652                                                 {
   16653                                                   /* 33222222222211111111110000000000
   16654                                                      10987654321098765432109876543210
   16655                                                      1x001110x10xxxxx1xxx10xxxxxxxxxx
   16656                                                      sm3tt2a.  */
   16657                                                   return 2356;
   16658                                                 }
   16659                                             }
   16660                                           else
   16661                                             {
   16662                                               if (((word >> 11) & 0x1) == 0)
   16663                                                 {
   16664                                                   if (((word >> 23) & 0x1) == 0)
   16665                                                     {
   16666                                                       /* 33222222222211111111110000000000
   16667                                                          10987654321098765432109876543210
   16668                                                          1x001110010xxxxx1xxx01xxxxxxxxxx
   16669                                                          sm3tt1b.  */
   16670                                                       return 2355;
   16671                                                     }
   16672                                                   else
   16673                                                     {
   16674                                                       /* 33222222222211111111110000000000
   16675                                                          10987654321098765432109876543210
   16676                                                          1x001110110xxxxx1xxx01xxxxxxxxxx
   16677                                                          sm4e.  */
   16678                                                       return 2360;
   16679                                                     }
   16680                                                 }
   16681                                               else
   16682                                                 {
   16683                                                   /* 33222222222211111111110000000000
   16684                                                      10987654321098765432109876543210
   16685                                                      1x001110x10xxxxx1xxx11xxxxxxxxxx
   16686                                                      sm3tt2b.  */
   16687                                                   return 2357;
   16688                                                 }
   16689                                             }
   16690                                         }
   16691                                     }
   16692                                 }
   16693                             }
   16694                           else
   16695                             {
   16696                               if (((word >> 10) & 0x1) == 0)
   16697                                 {
   16698                                   /* 33222222222211111111110000000000
   16699                                      10987654321098765432109876543210
   16700                                      xx101110xx0xxxxxxxxxx0xxxxxxxxxx
   16701                                      ext.  */
   16702                                   return 132;
   16703                                 }
   16704                               else
   16705                                 {
   16706                                   if (((word >> 15) & 0x1) == 0)
   16707                                     {
   16708                                       if (((word >> 22) & 0x1) == 0)
   16709                                         {
   16710                                           /* 33222222222211111111110000000000
   16711                                              10987654321098765432109876543210
   16712                                              xx101110x00xxxxx0xxxx1xxxxxxxxxx
   16713                                              ins.  */
   16714                                           return 156;
   16715                                         }
   16716                                       else
   16717                                         {
   16718                                           if (((word >> 11) & 0x1) == 0)
   16719                                             {
   16720                                               if (((word >> 12) & 0x1) == 0)
   16721                                                 {
   16722                                                   if (((word >> 13) & 0x1) == 0)
   16723                                                     {
   16724                                                       if (((word >> 23) & 0x1) == 0)
   16725                                                         {
   16726                                                           /* 33222222222211111111110000000000
   16727                                                              10987654321098765432109876543210
   16728                                                              xx101110010xxxxx0x0001xxxxxxxxxx
   16729                                                              fmaxnmp.  */
   16730                                                           return 343;
   16731                                                         }
   16732                                                       else
   16733                                                         {
   16734                                                           /* 33222222222211111111110000000000
   16735                                                              10987654321098765432109876543210
   16736                                                              xx101110110xxxxx0x0001xxxxxxxxxx
   16737                                                              fminnmp.  */
   16738                                                           return 359;
   16739                                                         }
   16740                                                     }
   16741                                                   else
   16742                                                     {
   16743                                                       if (((word >> 23) & 0x1) == 0)
   16744                                                         {
   16745                                                           /* 33222222222211111111110000000000
   16746                                                              10987654321098765432109876543210
   16747                                                              xx101110010xxxxx0x1001xxxxxxxxxx
   16748                                                              fcmge.  */
   16749                                                           return 349;
   16750                                                         }
   16751                                                       else
   16752                                                         {
   16753                                                           /* 33222222222211111111110000000000
   16754                                                              10987654321098765432109876543210
   16755                                                              xx101110110xxxxx0x1001xxxxxxxxxx
   16756                                                              fcmgt.  */
   16757                                                           return 363;
   16758                                                         }
   16759                                                     }
   16760                                                 }
   16761                                               else
   16762                                                 {
   16763                                                   if (((word >> 13) & 0x1) == 0)
   16764                                                     {
   16765                                                       if (((word >> 23) & 0x1) == 0)
   16766                                                         {
   16767                                                           /* 33222222222211111111110000000000
   16768                                                              10987654321098765432109876543210
   16769                                                              xx101110010xxxxx0x0101xxxxxxxxxx
   16770                                                              faddp.  */
   16771                                                           return 345;
   16772                                                         }
   16773                                                       else
   16774                                                         {
   16775                                                           /* 33222222222211111111110000000000
   16776                                                              10987654321098765432109876543210
   16777                                                              xx101110110xxxxx0x0101xxxxxxxxxx
   16778                                                              fabd.  */
   16779                                                           return 361;
   16780                                                         }
   16781                                                     }
   16782                                                   else
   16783                                                     {
   16784                                                       if (((word >> 23) & 0x1) == 0)
   16785                                                         {
   16786                                                           /* 33222222222211111111110000000000
   16787                                                              10987654321098765432109876543210
   16788                                                              xx101110010xxxxx0x1101xxxxxxxxxx
   16789                                                              fmaxp.  */
   16790                                                           return 353;
   16791                                                         }
   16792                                                       else
   16793                                                         {
   16794                                                           /* 33222222222211111111110000000000
   16795                                                              10987654321098765432109876543210
   16796                                                              xx101110110xxxxx0x1101xxxxxxxxxx
   16797                                                              fminp.  */
   16798                                                           return 367;
   16799                                                         }
   16800                                                     }
   16801                                                 }
   16802                                             }
   16803                                           else
   16804                                             {
   16805                                               if (((word >> 12) & 0x1) == 0)
   16806                                                 {
   16807                                                   if (((word >> 23) & 0x1) == 0)
   16808                                                     {
   16809                                                       /* 33222222222211111111110000000000
   16810                                                          10987654321098765432109876543210
   16811                                                          xx101110010xxxxx0xx011xxxxxxxxxx
   16812                                                          facge.  */
   16813                                                       return 351;
   16814                                                     }
   16815                                                   else
   16816                                                     {
   16817                                                       /* 33222222222211111111110000000000
   16818                                                          10987654321098765432109876543210
   16819                                                          xx101110110xxxxx0xx011xxxxxxxxxx
   16820                                                          facgt.  */
   16821                                                       return 365;
   16822                                                     }
   16823                                                 }
   16824                                               else
   16825                                                 {
   16826                                                   if (((word >> 13) & 0x1) == 0)
   16827                                                     {
   16828                                                       /* 33222222222211111111110000000000
   16829                                                          10987654321098765432109876543210
   16830                                                          xx101110x10xxxxx0x0111xxxxxxxxxx
   16831                                                          fmul.  */
   16832                                                       return 347;
   16833                                                     }
   16834                                                   else
   16835                                                     {
   16836                                                       /* 33222222222211111111110000000000
   16837                                                          10987654321098765432109876543210
   16838                                                          xx101110x10xxxxx0x1111xxxxxxxxxx
   16839                                                          fdiv.  */
   16840                                                       return 355;
   16841                                                     }
   16842                                                 }
   16843                                             }
   16844                                         }
   16845                                     }
   16846                                   else
   16847                                     {
   16848                                       if (((word >> 13) & 0x1) == 0)
   16849                                         {
   16850                                           if (((word >> 14) & 0x1) == 0)
   16851                                             {
   16852                                               if (((word >> 11) & 0x1) == 0)
   16853                                                 {
   16854                                                   if (((word >> 12) & 0x1) == 0)
   16855                                                     {
   16856                                                       /* 33222222222211111111110000000000
   16857                                                          10987654321098765432109876543210
   16858                                                          xx101110xx0xxxxx100001xxxxxxxxxx
   16859                                                          sqrdmlah.  */
   16860                                                       return 370;
   16861                                                     }
   16862                                                   else
   16863                                                     {
   16864                                                       /* 33222222222211111111110000000000
   16865                                                          10987654321098765432109876543210
   16866                                                          xx101110xx0xxxxx100101xxxxxxxxxx
   16867                                                          udot.  */
   16868                                                       return 2341;
   16869                                                     }
   16870                                                 }
   16871                                               else
   16872                                                 {
   16873                                                   /* 33222222222211111111110000000000
   16874                                                      10987654321098765432109876543210
   16875                                                      xx101110xx0xxxxx100x11xxxxxxxxxx
   16876                                                      sqrdmlsh.  */
   16877                                                   return 371;
   16878                                                 }
   16879                                             }
   16880                                           else
   16881                                             {
   16882                                               /* 33222222222211111111110000000000
   16883                                                  10987654321098765432109876543210
   16884                                                  xx101110xx0xxxxx110xx1xxxxxxxxxx
   16885                                                  fcmla.  */
   16886                                               return 372;
   16887                                             }
   16888                                         }
   16889                                       else
   16890                                         {
   16891                                           if (((word >> 11) & 0x1) == 0)
   16892                                             {
   16893                                               if (((word >> 14) & 0x1) == 0)
   16894                                                 {
   16895                                                   /* 33222222222211111111110000000000
   16896                                                      10987654321098765432109876543210
   16897                                                      xx101110xx0xxxxx101x01xxxxxxxxxx
   16898                                                      ummla.  */
   16899                                                   return 2417;
   16900                                                 }
   16901                                               else
   16902                                                 {
   16903                                                   /* 33222222222211111111110000000000
   16904                                                      10987654321098765432109876543210
   16905                                                      xx101110xx0xxxxx111x01xxxxxxxxxx
   16906                                                      fcadd.  */
   16907                                                   return 373;
   16908                                                 }
   16909                                             }
   16910                                           else
   16911                                             {
   16912                                               if (((word >> 12) & 0x1) == 0)
   16913                                                 {
   16914                                                   /* 33222222222211111111110000000000
   16915                                                      10987654321098765432109876543210
   16916                                                      xx101110xx0xxxxx1x1011xxxxxxxxxx
   16917                                                      bfmmla.  */
   16918                                                   return 2433;
   16919                                                 }
   16920                                               else
   16921                                                 {
   16922                                                   if (((word >> 23) & 0x1) == 0)
   16923                                                     {
   16924                                                       /* 33222222222211111111110000000000
   16925                                                          10987654321098765432109876543210
   16926                                                          xx1011100x0xxxxx1x1111xxxxxxxxxx
   16927                                                          bfdot.  */
   16928                                                       return 2431;
   16929                                                     }
   16930                                                   else
   16931                                                     {
   16932                                                       if (((word >> 30) & 0x1) == 0)
   16933                                                         {
   16934                                                           /* 33222222222211111111110000000000
   16935                                                              10987654321098765432109876543210
   16936                                                              x01011101x0xxxxx1x1111xxxxxxxxxx
   16937                                                              bfmlalb.  */
   16938                                                           return 2438;
   16939                                                         }
   16940                                                       else
   16941                                                         {
   16942                                                           /* 33222222222211111111110000000000
   16943                                                              10987654321098765432109876543210
   16944                                                              x11011101x0xxxxx1x1111xxxxxxxxxx
   16945                                                              bfmlalt.  */
   16946                                                           return 2437;
   16947                                                         }
   16948                                                     }
   16949                                                 }
   16950                                             }
   16951                                         }
   16952                                     }
   16953                                 }
   16954                             }
   16955                         }
   16956                       else
   16957                         {
   16958                           if (((word >> 29) & 0x1) == 0)
   16959                             {
   16960                               if (((word >> 30) & 0x1) == 0)
   16961                                 {
   16962                                   if (((word >> 16) & 0x1) == 0)
   16963                                     {
   16964                                       if (((word >> 17) & 0x1) == 0)
   16965                                         {
   16966                                           /* 33222222222211111111110000000000
   16967                                              10987654321098765432109876543210
   16968                                              x0011110xx0xxx00xxxxxxxxxxxxxxxx
   16969                                              fcvtzs.  */
   16970                                           return 764;
   16971                                         }
   16972                                       else
   16973                                         {
   16974                                           /* 33222222222211111111110000000000
   16975                                              10987654321098765432109876543210
   16976                                              x0011110xx0xxx10xxxxxxxxxxxxxxxx
   16977                                              scvtf.  */
   16978                                           return 760;
   16979                                         }
   16980                                     }
   16981                                   else
   16982                                     {
   16983                                       if (((word >> 17) & 0x1) == 0)
   16984                                         {
   16985                                           /* 33222222222211111111110000000000
   16986                                              10987654321098765432109876543210
   16987                                              x0011110xx0xxx01xxxxxxxxxxxxxxxx
   16988                                              fcvtzu.  */
   16989                                           return 766;
   16990                                         }
   16991                                       else
   16992                                         {
   16993                                           /* 33222222222211111111110000000000
   16994                                              10987654321098765432109876543210
   16995                                              x0011110xx0xxx11xxxxxxxxxxxxxxxx
   16996                                              ucvtf.  */
   16997                                           return 762;
   16998                                         }
   16999                                     }
   17000                                 }
   17001                               else
   17002                                 {
   17003                                   if (((word >> 10) & 0x1) == 0)
   17004                                     {
   17005                                       if (((word >> 12) & 0x1) == 0)
   17006                                         {
   17007                                           if (((word >> 13) & 0x1) == 0)
   17008                                             {
   17009                                               if (((word >> 14) & 0x1) == 0)
   17010                                                 {
   17011                                                   /* 33222222222211111111110000000000
   17012                                                      10987654321098765432109876543210
   17013                                                      x1011110xx0xxxxxx000x0xxxxxxxxxx
   17014                                                      sha1c.  */
   17015                                                   return 678;
   17016                                                 }
   17017                                               else
   17018                                                 {
   17019                                                   /* 33222222222211111111110000000000
   17020                                                      10987654321098765432109876543210
   17021                                                      x1011110xx0xxxxxx100x0xxxxxxxxxx
   17022                                                      sha256h.  */
   17023                                                   return 682;
   17024                                                 }
   17025                                             }
   17026                                           else
   17027                                             {
   17028                                               if (((word >> 14) & 0x1) == 0)
   17029                                                 {
   17030                                                   /* 33222222222211111111110000000000
   17031                                                      10987654321098765432109876543210
   17032                                                      x1011110xx0xxxxxx010x0xxxxxxxxxx
   17033                                                      sha1m.  */
   17034                                                   return 680;
   17035                                                 }
   17036                                               else
   17037                                                 {
   17038                                                   /* 33222222222211111111110000000000
   17039                                                      10987654321098765432109876543210
   17040                                                      x1011110xx0xxxxxx110x0xxxxxxxxxx
   17041                                                      sha256su1.  */
   17042                                                   return 684;
   17043                                                 }
   17044                                             }
   17045                                         }
   17046                                       else
   17047                                         {
   17048                                           if (((word >> 13) & 0x1) == 0)
   17049                                             {
   17050                                               if (((word >> 14) & 0x1) == 0)
   17051                                                 {
   17052                                                   /* 33222222222211111111110000000000
   17053                                                      10987654321098765432109876543210
   17054                                                      x1011110xx0xxxxxx001x0xxxxxxxxxx
   17055                                                      sha1p.  */
   17056                                                   return 679;
   17057                                                 }
   17058                                               else
   17059                                                 {
   17060                                                   /* 33222222222211111111110000000000
   17061                                                      10987654321098765432109876543210
   17062                                                      x1011110xx0xxxxxx101x0xxxxxxxxxx
   17063                                                      sha256h2.  */
   17064                                                   return 683;
   17065                                                 }
   17066                                             }
   17067                                           else
   17068                                             {
   17069                                               /* 33222222222211111111110000000000
   17070                                                  10987654321098765432109876543210
   17071                                                  x1011110xx0xxxxxxx11x0xxxxxxxxxx
   17072                                                  sha1su0.  */
   17073                                               return 681;
   17074                                             }
   17075                                         }
   17076                                     }
   17077                                   else
   17078                                     {
   17079                                       if (((word >> 11) & 0x1) == 0)
   17080                                         {
   17081                                           if (((word >> 13) & 0x1) == 0)
   17082                                             {
   17083                                               /* 33222222222211111111110000000000
   17084                                                  10987654321098765432109876543210
   17085                                                  x1011110xx0xxxxxxx0x01xxxxxxxxxx
   17086                                                  dup.  */
   17087                                               return 535;
   17088                                             }
   17089                                           else
   17090                                             {
   17091                                               /* 33222222222211111111110000000000
   17092                                                  10987654321098765432109876543210
   17093                                                  x1011110xx0xxxxxxx1x01xxxxxxxxxx
   17094                                                  fcmeq.  */
   17095                                               return 556;
   17096                                             }
   17097                                         }
   17098                                       else
   17099                                         {
   17100                                           if (((word >> 13) & 0x1) == 0)
   17101                                             {
   17102                                               /* 33222222222211111111110000000000
   17103                                                  10987654321098765432109876543210
   17104                                                  x1011110xx0xxxxxxx0x11xxxxxxxxxx
   17105                                                  fmulx.  */
   17106                                               return 554;
   17107                                             }
   17108                                           else
   17109                                             {
   17110                                               if (((word >> 23) & 0x1) == 0)
   17111                                                 {
   17112                                                   /* 33222222222211111111110000000000
   17113                                                      10987654321098765432109876543210
   17114                                                      x10111100x0xxxxxxx1x11xxxxxxxxxx
   17115                                                      frecps.  */
   17116                                                   return 558;
   17117                                                 }
   17118                                               else
   17119                                                 {
   17120                                                   /* 33222222222211111111110000000000
   17121                                                      10987654321098765432109876543210
   17122                                                      x10111101x0xxxxxxx1x11xxxxxxxxxx
   17123                                                      frsqrts.  */
   17124                                                   return 560;
   17125                                                 }
   17126                                             }
   17127                                         }
   17128                                     }
   17129                                 }
   17130                             }
   17131                           else
   17132                             {
   17133                               if (((word >> 11) & 0x1) == 0)
   17134                                 {
   17135                                   if (((word >> 12) & 0x1) == 0)
   17136                                     {
   17137                                       if (((word >> 13) & 0x1) == 0)
   17138                                         {
   17139                                           /* 33222222222211111111110000000000
   17140                                              10987654321098765432109876543210
   17141                                              xx111110xx0xxxxxxx000xxxxxxxxxxx
   17142                                              sqrdmlah.  */
   17143                                           return 588;
   17144                                         }
   17145                                       else
   17146                                         {
   17147                                           if (((word >> 23) & 0x1) == 0)
   17148                                             {
   17149                                               /* 33222222222211111111110000000000
   17150                                                  10987654321098765432109876543210
   17151                                                  xx1111100x0xxxxxxx100xxxxxxxxxxx
   17152                                                  fcmge.  */
   17153                                               return 573;
   17154                                             }
   17155                                           else
   17156                                             {
   17157                                               /* 33222222222211111111110000000000
   17158                                                  10987654321098765432109876543210
   17159                                                  xx1111101x0xxxxxxx100xxxxxxxxxxx
   17160                                                  fcmgt.  */
   17161                                               return 579;
   17162                                             }
   17163                                         }
   17164                                     }
   17165                                   else
   17166                                     {
   17167                                       /* 33222222222211111111110000000000
   17168                                          10987654321098765432109876543210
   17169                                          xx111110xx0xxxxxxxx10xxxxxxxxxxx
   17170                                          fabd.  */
   17171                                       return 577;
   17172                                     }
   17173                                 }
   17174                               else
   17175                                 {
   17176                                   if (((word >> 13) & 0x1) == 0)
   17177                                     {
   17178                                       /* 33222222222211111111110000000000
   17179                                          10987654321098765432109876543210
   17180                                          xx111110xx0xxxxxxx0x1xxxxxxxxxxx
   17181                                          sqrdmlsh.  */
   17182                                       return 589;
   17183                                     }
   17184                                   else
   17185                                     {
   17186                                       if (((word >> 23) & 0x1) == 0)
   17187                                         {
   17188                                           /* 33222222222211111111110000000000
   17189                                              10987654321098765432109876543210
   17190                                              xx1111100x0xxxxxxx1x1xxxxxxxxxxx
   17191                                              facge.  */
   17192                                           return 575;
   17193                                         }
   17194                                       else
   17195                                         {
   17196                                           /* 33222222222211111111110000000000
   17197                                              10987654321098765432109876543210
   17198                                              xx1111101x0xxxxxxx1x1xxxxxxxxxxx
   17199                                              facgt.  */
   17200                                           return 581;
   17201                                         }
   17202                                     }
   17203                                 }
   17204                             }
   17205                         }
   17206                     }
   17207                   else
   17208                     {
   17209                       if (((word >> 28) & 0x1) == 0)
   17210                         {
   17211                           if (((word >> 15) & 0x1) == 0)
   17212                             {
   17213                               if (((word >> 29) & 0x1) == 0)
   17214                                 {
   17215                                   if (((word >> 31) & 0x1) == 0)
   17216                                     {
   17217                                       if (((word >> 10) & 0x1) == 0)
   17218                                         {
   17219                                           if (((word >> 11) & 0x1) == 0)
   17220                                             {
   17221                                               if (((word >> 12) & 0x1) == 0)
   17222                                                 {
   17223                                                   if (((word >> 13) & 0x1) == 0)
   17224                                                     {
   17225                                                       if (((word >> 14) & 0x1) == 0)
   17226                                                         {
   17227                                                           if (((word >> 30) & 0x1) == 0)
   17228                                                             {
   17229                                                               /* 33222222222211111111110000000000
   17230                                                                  10987654321098765432109876543210
   17231                                                                  00001110xx1xxxxx000000xxxxxxxxxx
   17232                                                                  saddl.  */
   17233                                                               return 44;
   17234                                                             }
   17235                                                           else
   17236                                                             {
   17237                                                               /* 33222222222211111111110000000000
   17238                                                                  10987654321098765432109876543210
   17239                                                                  01001110xx1xxxxx000000xxxxxxxxxx
   17240                                                                  saddl2.  */
   17241                                                               return 45;
   17242                                                             }
   17243                                                         }
   17244                                                       else
   17245                                                         {
   17246                                                           if (((word >> 30) & 0x1) == 0)
   17247                                                             {
   17248                                                               /* 33222222222211111111110000000000
   17249                                                                  10987654321098765432109876543210
   17250                                                                  00001110xx1xxxxx010000xxxxxxxxxx
   17251                                                                  addhn.  */
   17252                                                               return 52;
   17253                                                             }
   17254                                                           else
   17255                                                             {
   17256                                                               /* 33222222222211111111110000000000
   17257                                                                  10987654321098765432109876543210
   17258                                                                  01001110xx1xxxxx010000xxxxxxxxxx
   17259                                                                  addhn2.  */
   17260                                                               return 53;
   17261                                                             }
   17262                                                         }
   17263                                                     }
   17264                                                   else
   17265                                                     {
   17266                                                       if (((word >> 14) & 0x1) == 0)
   17267                                                         {
   17268                                                           if (((word >> 30) & 0x1) == 0)
   17269                                                             {
   17270                                                               /* 33222222222211111111110000000000
   17271                                                                  10987654321098765432109876543210
   17272                                                                  00001110xx1xxxxx001000xxxxxxxxxx
   17273                                                                  ssubl.  */
   17274                                                               return 48;
   17275                                                             }
   17276                                                           else
   17277                                                             {
   17278                                                               /* 33222222222211111111110000000000
   17279                                                                  10987654321098765432109876543210
   17280                                                                  01001110xx1xxxxx001000xxxxxxxxxx
   17281                                                                  ssubl2.  */
   17282                                                               return 49;
   17283                                                             }
   17284                                                         }
   17285                                                       else
   17286                                                         {
   17287                                                           if (((word >> 30) & 0x1) == 0)
   17288                                                             {
   17289                                                               /* 33222222222211111111110000000000
   17290                                                                  10987654321098765432109876543210
   17291                                                                  00001110xx1xxxxx011000xxxxxxxxxx
   17292                                                                  subhn.  */
   17293                                                               return 56;
   17294                                                             }
   17295                                                           else
   17296                                                             {
   17297                                                               /* 33222222222211111111110000000000
   17298                                                                  10987654321098765432109876543210
   17299                                                                  01001110xx1xxxxx011000xxxxxxxxxx
   17300                                                                  subhn2.  */
   17301                                                               return 57;
   17302                                                             }
   17303                                                         }
   17304                                                     }
   17305                                                 }
   17306                                               else
   17307                                                 {
   17308                                                   if (((word >> 13) & 0x1) == 0)
   17309                                                     {
   17310                                                       if (((word >> 14) & 0x1) == 0)
   17311                                                         {
   17312                                                           if (((word >> 30) & 0x1) == 0)
   17313                                                             {
   17314                                                               /* 33222222222211111111110000000000
   17315                                                                  10987654321098765432109876543210
   17316                                                                  00001110xx1xxxxx000100xxxxxxxxxx
   17317                                                                  saddw.  */
   17318                                                               return 46;
   17319                                                             }
   17320                                                           else
   17321                                                             {
   17322                                                               /* 33222222222211111111110000000000
   17323                                                                  10987654321098765432109876543210
   17324                                                                  01001110xx1xxxxx000100xxxxxxxxxx
   17325                                                                  saddw2.  */
   17326                                                               return 47;
   17327                                                             }
   17328                                                         }
   17329                                                       else
   17330                                                         {
   17331                                                           if (((word >> 30) & 0x1) == 0)
   17332                                                             {
   17333                                                               /* 33222222222211111111110000000000
   17334                                                                  10987654321098765432109876543210
   17335                                                                  00001110xx1xxxxx010100xxxxxxxxxx
   17336                                                                  sabal.  */
   17337                                                               return 54;
   17338                                                             }
   17339                                                           else
   17340                                                             {
   17341                                                               /* 33222222222211111111110000000000
   17342                                                                  10987654321098765432109876543210
   17343                                                                  01001110xx1xxxxx010100xxxxxxxxxx
   17344                                                                  sabal2.  */
   17345                                                               return 55;
   17346                                                             }
   17347                                                         }
   17348                                                     }
   17349                                                   else
   17350                                                     {
   17351                                                       if (((word >> 14) & 0x1) == 0)
   17352                                                         {
   17353                                                           if (((word >> 30) & 0x1) == 0)
   17354                                                             {
   17355                                                               /* 33222222222211111111110000000000
   17356                                                                  10987654321098765432109876543210
   17357                                                                  00001110xx1xxxxx001100xxxxxxxxxx
   17358                                                                  ssubw.  */
   17359                                                               return 50;
   17360                                                             }
   17361                                                           else
   17362                                                             {
   17363                                                               /* 33222222222211111111110000000000
   17364                                                                  10987654321098765432109876543210
   17365                                                                  01001110xx1xxxxx001100xxxxxxxxxx
   17366                                                                  ssubw2.  */
   17367                                                               return 51;
   17368                                                             }
   17369                                                         }
   17370                                                       else
   17371                                                         {
   17372                                                           if (((word >> 30) & 0x1) == 0)
   17373                                                             {
   17374                                                               /* 33222222222211111111110000000000
   17375                                                                  10987654321098765432109876543210
   17376                                                                  00001110xx1xxxxx011100xxxxxxxxxx
   17377                                                                  sabdl.  */
   17378                                                               return 58;
   17379                                                             }
   17380                                                           else
   17381                                                             {
   17382                                                               /* 33222222222211111111110000000000
   17383                                                                  10987654321098765432109876543210
   17384                                                                  01001110xx1xxxxx011100xxxxxxxxxx
   17385                                                                  sabdl2.  */
   17386                                                               return 59;
   17387                                                             }
   17388                                                         }
   17389                                                     }
   17390                                                 }
   17391                                             }
   17392                                           else
   17393                                             {
   17394                                               if (((word >> 12) & 0x1) == 0)
   17395                                                 {
   17396                                                   if (((word >> 13) & 0x1) == 0)
   17397                                                     {
   17398                                                       if (((word >> 14) & 0x1) == 0)
   17399                                                         {
   17400                                                           /* 33222222222211111111110000000000
   17401                                                              10987654321098765432109876543210
   17402                                                              0x001110xx1xxxxx000010xxxxxxxxxx
   17403                                                              rev64.  */
   17404                                                           return 162;
   17405                                                         }
   17406                                                       else
   17407                                                         {
   17408                                                           if (((word >> 16) & 0x1) == 0)
   17409                                                             {
   17410                                                               if (((word >> 19) & 0x1) == 0)
   17411                                                                 {
   17412                                                                   /* 33222222222211111111110000000000
   17413                                                                      10987654321098765432109876543210
   17414                                                                      0x001110xx1x0xx0010010xxxxxxxxxx
   17415                                                                      cls.  */
   17416                                                                   return 166;
   17417                                                                 }
   17418                                                               else
   17419                                                                 {
   17420                                                                   /* 33222222222211111111110000000000
   17421                                                                      10987654321098765432109876543210
   17422                                                                      0x001110xx1x1xx0010010xxxxxxxxxx
   17423                                                                      aese.  */
   17424                                                                   return 671;
   17425                                                                 }
   17426                                                             }
   17427                                                           else
   17428                                                             {
   17429                                                               if (((word >> 30) & 0x1) == 0)
   17430                                                                 {
   17431                                                                   /* 33222222222211111111110000000000
   17432                                                                      10987654321098765432109876543210
   17433                                                                      00001110xx1xxxx1010010xxxxxxxxxx
   17434                                                                      sqxtn.  */
   17435                                                                   return 176;
   17436                                                                 }
   17437                                                               else
   17438                                                                 {
   17439                                                                   /* 33222222222211111111110000000000
   17440                                                                      10987654321098765432109876543210
   17441                                                                      01001110xx1xxxx1010010xxxxxxxxxx
   17442                                                                      sqxtn2.  */
   17443                                                                   return 177;
   17444                                                                 }
   17445                                                             }
   17446                                                         }
   17447                                                     }
   17448                                                   else
   17449                                                     {
   17450                                                       if (((word >> 14) & 0x1) == 0)
   17451                                                         {
   17452                                                           if (((word >> 16) & 0x1) == 0)
   17453                                                             {
   17454                                                               /* 33222222222211111111110000000000
   17455                                                                  10987654321098765432109876543210
   17456                                                                  0x001110xx1xxxx0001010xxxxxxxxxx
   17457                                                                  saddlp.  */
   17458                                                               return 164;
   17459                                                             }
   17460                                                           else
   17461                                                             {
   17462                                                               if (((word >> 30) & 0x1) == 0)
   17463                                                                 {
   17464                                                                   /* 33222222222211111111110000000000
   17465                                                                      10987654321098765432109876543210
   17466                                                                      00001110xx1xxxx1001010xxxxxxxxxx
   17467                                                                      xtn.  */
   17468                                                                   return 174;
   17469                                                                 }
   17470                                                               else
   17471                                                                 {
   17472                                                                   /* 33222222222211111111110000000000
   17473                                                                      10987654321098765432109876543210
   17474                                                                      01001110xx1xxxx1001010xxxxxxxxxx
   17475                                                                      xtn2.  */
   17476                                                                   return 175;
   17477                                                                 }
   17478                                                             }
   17479                                                         }
   17480                                                       else
   17481                                                         {
   17482                                                           if (((word >> 16) & 0x1) == 0)
   17483                                                             {
   17484                                                               if (((word >> 19) & 0x1) == 0)
   17485                                                                 {
   17486                                                                   /* 33222222222211111111110000000000
   17487                                                                      10987654321098765432109876543210
   17488                                                                      0x001110xx1x0xx0011010xxxxxxxxxx
   17489                                                                      sadalp.  */
   17490                                                                   return 168;
   17491                                                                 }
   17492                                                               else
   17493                                                                 {
   17494                                                                   /* 33222222222211111111110000000000
   17495                                                                      10987654321098765432109876543210
   17496                                                                      0x001110xx1x1xx0011010xxxxxxxxxx
   17497                                                                      aesmc.  */
   17498                                                                   return 673;
   17499                                                                 }
   17500                                                             }
   17501                                                           else
   17502                                                             {
   17503                                                               if (((word >> 23) & 0x1) == 0)
   17504                                                                 {
   17505                                                                   if (((word >> 30) & 0x1) == 0)
   17506                                                                     {
   17507                                                                       /* 33222222222211111111110000000000
   17508                                                                          10987654321098765432109876543210
   17509                                                                          000011100x1xxxx1011010xxxxxxxxxx
   17510                                                                          fcvtn.  */
   17511                                                                       return 178;
   17512                                                                     }
   17513                                                                   else
   17514                                                                     {
   17515                                                                       /* 33222222222211111111110000000000
   17516                                                                          10987654321098765432109876543210
   17517                                                                          010011100x1xxxx1011010xxxxxxxxxx
   17518                                                                          fcvtn2.  */
   17519                                                                       return 179;
   17520                                                                     }
   17521                                                                 }
   17522                                                               else
   17523                                                                 {
   17524                                                                   if (((word >> 30) & 0x1) == 0)
   17525                                                                     {
   17526                                                                       /* 33222222222211111111110000000000
   17527                                                                          10987654321098765432109876543210
   17528                                                                          000011101x1xxxx1011010xxxxxxxxxx
   17529                                                                          bfcvtn.  */
   17530                                                                       return 2434;
   17531                                                                     }
   17532                                                                   else
   17533                                                                     {
   17534                                                                       /* 33222222222211111111110000000000
   17535                                                                          10987654321098765432109876543210
   17536                                                                          010011101x1xxxx1011010xxxxxxxxxx
   17537                                                                          bfcvtn2.  */
   17538                                                                       return 2435;
   17539                                                                     }
   17540                                                                 }
   17541                                                             }
   17542                                                         }
   17543                                                     }
   17544                                                 }
   17545                                               else
   17546                                                 {
   17547                                                   if (((word >> 13) & 0x1) == 0)
   17548                                                     {
   17549                                                       if (((word >> 14) & 0x1) == 0)
   17550                                                         {
   17551                                                           /* 33222222222211111111110000000000
   17552                                                              10987654321098765432109876543210
   17553                                                              0x001110xx1xxxxx000110xxxxxxxxxx
   17554                                                              rev16.  */
   17555                                                           return 163;
   17556                                                         }
   17557                                                       else
   17558                                                         {
   17559                                                           if (((word >> 19) & 0x1) == 0)
   17560                                                             {
   17561                                                               /* 33222222222211111111110000000000
   17562                                                                  10987654321098765432109876543210
   17563                                                                  0x001110xx1x0xxx010110xxxxxxxxxx
   17564                                                                  cnt.  */
   17565                                                               return 167;
   17566                                                             }
   17567                                                           else
   17568                                                             {
   17569                                                               /* 33222222222211111111110000000000
   17570                                                                  10987654321098765432109876543210
   17571                                                                  0x001110xx1x1xxx010110xxxxxxxxxx
   17572                                                                  aesd.  */
   17573                                                               return 672;
   17574                                                             }
   17575                                                         }
   17576                                                     }
   17577                                                   else
   17578                                                     {
   17579                                                       if (((word >> 14) & 0x1) == 0)
   17580                                                         {
   17581                                                           if (((word >> 20) & 0x1) == 0)
   17582                                                             {
   17583                                                               /* 33222222222211111111110000000000
   17584                                                                  10987654321098765432109876543210
   17585                                                                  0x001110xx10xxxx001110xxxxxxxxxx
   17586                                                                  suqadd.  */
   17587                                                               return 165;
   17588                                                             }
   17589                                                           else
   17590                                                             {
   17591                                                               /* 33222222222211111111110000000000
   17592                                                                  10987654321098765432109876543210
   17593                                                                  0x001110xx11xxxx001110xxxxxxxxxx
   17594                                                                  saddlv.  */
   17595                                                               return 29;
   17596                                                             }
   17597                                                         }
   17598                                                       else
   17599                                                         {
   17600                                                           if (((word >> 16) & 0x1) == 0)
   17601                                                             {
   17602                                                               if (((word >> 19) & 0x1) == 0)
   17603                                                                 {
   17604                                                                   /* 33222222222211111111110000000000
   17605                                                                      10987654321098765432109876543210
   17606                                                                      0x001110xx1x0xx0011110xxxxxxxxxx
   17607                                                                      sqabs.  */
   17608                                                                   return 169;
   17609                                                                 }
   17610                                                               else
   17611                                                                 {
   17612                                                                   /* 33222222222211111111110000000000
   17613                                                                      10987654321098765432109876543210
   17614                                                                      0x001110xx1x1xx0011110xxxxxxxxxx
   17615                                                                      aesimc.  */
   17616                                                                   return 674;
   17617                                                                 }
   17618                                                             }
   17619                                                           else
   17620                                                             {
   17621                                                               if (((word >> 30) & 0x1) == 0)
   17622                                                                 {
   17623                                                                   /* 33222222222211111111110000000000
   17624                                                                      10987654321098765432109876543210
   17625                                                                      00001110xx1xxxx1011110xxxxxxxxxx
   17626                                                                      fcvtl.  */
   17627                                                                   return 180;
   17628                                                                 }
   17629                                                               else
   17630                                                                 {
   17631                                                                   /* 33222222222211111111110000000000
   17632                                                                      10987654321098765432109876543210
   17633                                                                      01001110xx1xxxx1011110xxxxxxxxxx
   17634                                                                      fcvtl2.  */
   17635                                                                   return 181;
   17636                                                                 }
   17637                                                             }
   17638                                                         }
   17639                                                     }
   17640                                                 }
   17641                                             }
   17642                                         }
   17643                                       else
   17644                                         {
   17645                                           if (((word >> 11) & 0x1) == 0)
   17646                                             {
   17647                                               if (((word >> 12) & 0x1) == 0)
   17648                                                 {
   17649                                                   if (((word >> 13) & 0x1) == 0)
   17650                                                     {
   17651                                                       if (((word >> 14) & 0x1) == 0)
   17652                                                         {
   17653                                                           /* 33222222222211111111110000000000
   17654                                                              10987654321098765432109876543210
   17655                                                              0x001110xx1xxxxx000001xxxxxxxxxx
   17656                                                              shadd.  */
   17657                                                           return 268;
   17658                                                         }
   17659                                                       else
   17660                                                         {
   17661                                                           /* 33222222222211111111110000000000
   17662                                                              10987654321098765432109876543210
   17663                                                              0x001110xx1xxxxx010001xxxxxxxxxx
   17664                                                              sshl.  */
   17665                                                           return 275;
   17666                                                         }
   17667                                                     }
   17668                                                   else
   17669                                                     {
   17670                                                       if (((word >> 14) & 0x1) == 0)
   17671                                                         {
   17672                                                           /* 33222222222211111111110000000000
   17673                                                              10987654321098765432109876543210
   17674                                                              0x001110xx1xxxxx001001xxxxxxxxxx
   17675                                                              shsub.  */
   17676                                                           return 271;
   17677                                                         }
   17678                                                       else
   17679                                                         {
   17680                                                           /* 33222222222211111111110000000000
   17681                                                              10987654321098765432109876543210
   17682                                                              0x001110xx1xxxxx011001xxxxxxxxxx
   17683                                                              smax.  */
   17684                                                           return 279;
   17685                                                         }
   17686                                                     }
   17687                                                 }
   17688                                               else
   17689                                                 {
   17690                                                   if (((word >> 13) & 0x1) == 0)
   17691                                                     {
   17692                                                       if (((word >> 14) & 0x1) == 0)
   17693                                                         {
   17694                                                           /* 33222222222211111111110000000000
   17695                                                              10987654321098765432109876543210
   17696                                                              0x001110xx1xxxxx000101xxxxxxxxxx
   17697                                                              srhadd.  */
   17698                                                           return 270;
   17699                                                         }
   17700                                                       else
   17701                                                         {
   17702                                                           /* 33222222222211111111110000000000
   17703                                                              10987654321098765432109876543210
   17704                                                              0x001110xx1xxxxx010101xxxxxxxxxx
   17705                                                              srshl.  */
   17706                                                           return 277;
   17707                                                         }
   17708                                                     }
   17709                                                   else
   17710                                                     {
   17711                                                       if (((word >> 14) & 0x1) == 0)
   17712                                                         {
   17713                                                           /* 33222222222211111111110000000000
   17714                                                              10987654321098765432109876543210
   17715                                                              0x001110xx1xxxxx001101xxxxxxxxxx
   17716                                                              cmgt.  */
   17717                                                           return 273;
   17718                                                         }
   17719                                                       else
   17720                                                         {
   17721                                                           /* 33222222222211111111110000000000
   17722                                                              10987654321098765432109876543210
   17723                                                              0x001110xx1xxxxx011101xxxxxxxxxx
   17724                                                              sabd.  */
   17725                                                           return 281;
   17726                                                         }
   17727                                                     }
   17728                                                 }
   17729                                             }
   17730                                           else
   17731                                             {
   17732                                               if (((word >> 12) & 0x1) == 0)
   17733                                                 {
   17734                                                   if (((word >> 13) & 0x1) == 0)
   17735                                                     {
   17736                                                       if (((word >> 14) & 0x1) == 0)
   17737                                                         {
   17738                                                           /* 33222222222211111111110000000000
   17739                                                              10987654321098765432109876543210
   17740                                                              0x001110xx1xxxxx000011xxxxxxxxxx
   17741                                                              sqadd.  */
   17742                                                           return 269;
   17743                                                         }
   17744                                                       else
   17745                                                         {
   17746                                                           /* 33222222222211111111110000000000
   17747                                                              10987654321098765432109876543210
   17748                                                              0x001110xx1xxxxx010011xxxxxxxxxx
   17749                                                              sqshl.  */
   17750                                                           return 276;
   17751                                                         }
   17752                                                     }
   17753                                                   else
   17754                                                     {
   17755                                                       if (((word >> 14) & 0x1) == 0)
   17756                                                         {
   17757                                                           /* 33222222222211111111110000000000
   17758                                                              10987654321098765432109876543210
   17759                                                              0x001110xx1xxxxx001011xxxxxxxxxx
   17760                                                              sqsub.  */
   17761                                                           return 272;
   17762                                                         }
   17763                                                       else
   17764                                                         {
   17765                                                           /* 33222222222211111111110000000000
   17766                                                              10987654321098765432109876543210
   17767                                                              0x001110xx1xxxxx011011xxxxxxxxxx
   17768                                                              smin.  */
   17769                                                           return 280;
   17770                                                         }
   17771                                                     }
   17772                                                 }
   17773                                               else
   17774                                                 {
   17775                                                   if (((word >> 13) & 0x1) == 0)
   17776                                                     {
   17777                                                       if (((word >> 14) & 0x1) == 0)
   17778                                                         {
   17779                                                           if (((word >> 22) & 0x1) == 0)
   17780                                                             {
   17781                                                               if (((word >> 23) & 0x1) == 0)
   17782                                                                 {
   17783                                                                   /* 33222222222211111111110000000000
   17784                                                                      10987654321098765432109876543210
   17785                                                                      0x001110001xxxxx000111xxxxxxxxxx
   17786                                                                      and.  */
   17787                                                                   return 305;
   17788                                                                 }
   17789                                                               else
   17790                                                                 {
   17791                                                                   /* 33222222222211111111110000000000
   17792                                                                      10987654321098765432109876543210
   17793                                                                      0x001110101xxxxx000111xxxxxxxxxx
   17794                                                                      orr.  */
   17795                                                                   return 317;
   17796                                                                 }
   17797                                                             }
   17798                                                           else
   17799                                                             {
   17800                                                               if (((word >> 23) & 0x1) == 0)
   17801                                                                 {
   17802                                                                   /* 33222222222211111111110000000000
   17803                                                                      10987654321098765432109876543210
   17804                                                                      0x001110011xxxxx000111xxxxxxxxxx
   17805                                                                      bic.  */
   17806                                                                   return 306;
   17807                                                                 }
   17808                                                               else
   17809                                                                 {
   17810                                                                   /* 33222222222211111111110000000000
   17811                                                                      10987654321098765432109876543210
   17812                                                                      0x001110111xxxxx000111xxxxxxxxxx
   17813                                                                      orn.  */
   17814                                                                   return 319;
   17815                                                                 }
   17816                                                             }
   17817                                                         }
   17818                                                       else
   17819                                                         {
   17820                                                           /* 33222222222211111111110000000000
   17821                                                              10987654321098765432109876543210
   17822                                                              0x001110xx1xxxxx010111xxxxxxxxxx
   17823                                                              sqrshl.  */
   17824                                                           return 278;
   17825                                                         }
   17826                                                     }
   17827                                                   else
   17828                                                     {
   17829                                                       if (((word >> 14) & 0x1) == 0)
   17830                                                         {
   17831                                                           /* 33222222222211111111110000000000
   17832                                                              10987654321098765432109876543210
   17833                                                              0x001110xx1xxxxx001111xxxxxxxxxx
   17834                                                              cmge.  */
   17835                                                           return 274;
   17836                                                         }
   17837                                                       else
   17838                                                         {
   17839                                                           /* 33222222222211111111110000000000
   17840                                                              10987654321098765432109876543210
   17841                                                              0x001110xx1xxxxx011111xxxxxxxxxx
   17842                                                              saba.  */
   17843                                                           return 282;
   17844                                                         }
   17845                                                     }
   17846                                                 }
   17847                                             }
   17848                                         }
   17849                                     }
   17850                                   else
   17851                                     {
   17852                                       /* 33222222222211111111110000000000
   17853                                          10987654321098765432109876543210
   17854                                          1x001110xx1xxxxx0xxxxxxxxxxxxxxx
   17855                                          bcax.  */
   17856                                       return 2352;
   17857                                     }
   17858                                 }
   17859                               else
   17860                                 {
   17861                                   if (((word >> 10) & 0x1) == 0)
   17862                                     {
   17863                                       if (((word >> 11) & 0x1) == 0)
   17864                                         {
   17865                                           if (((word >> 12) & 0x1) == 0)
   17866                                             {
   17867                                               if (((word >> 13) & 0x1) == 0)
   17868                                                 {
   17869                                                   if (((word >> 14) & 0x1) == 0)
   17870                                                     {
   17871                                                       if (((word >> 30) & 0x1) == 0)
   17872                                                         {
   17873                                                           /* 33222222222211111111110000000000
   17874                                                              10987654321098765432109876543210
   17875                                                              x0101110xx1xxxxx000000xxxxxxxxxx
   17876                                                              uaddl.  */
   17877                                                           return 76;
   17878                                                         }
   17879                                                       else
   17880                                                         {
   17881                                                           /* 33222222222211111111110000000000
   17882                                                              10987654321098765432109876543210
   17883                                                              x1101110xx1xxxxx000000xxxxxxxxxx
   17884                                                              uaddl2.  */
   17885                                                           return 77;
   17886                                                         }
   17887                                                     }
   17888                                                   else
   17889                                                     {
   17890                                                       if (((word >> 30) & 0x1) == 0)
   17891                                                         {
   17892                                                           /* 33222222222211111111110000000000
   17893                                                              10987654321098765432109876543210
   17894                                                              x0101110xx1xxxxx010000xxxxxxxxxx
   17895                                                              raddhn.  */
   17896                                                           return 84;
   17897                                                         }
   17898                                                       else
   17899                                                         {
   17900                                                           /* 33222222222211111111110000000000
   17901                                                              10987654321098765432109876543210
   17902                                                              x1101110xx1xxxxx010000xxxxxxxxxx
   17903                                                              raddhn2.  */
   17904                                                           return 85;
   17905                                                         }
   17906                                                     }
   17907                                                 }
   17908                                               else
   17909                                                 {
   17910                                                   if (((word >> 14) & 0x1) == 0)
   17911                                                     {
   17912                                                       if (((word >> 30) & 0x1) == 0)
   17913                                                         {
   17914                                                           /* 33222222222211111111110000000000
   17915                                                              10987654321098765432109876543210
   17916                                                              x0101110xx1xxxxx001000xxxxxxxxxx
   17917                                                              usubl.  */
   17918                                                           return 80;
   17919                                                         }
   17920                                                       else
   17921                                                         {
   17922                                                           /* 33222222222211111111110000000000
   17923                                                              10987654321098765432109876543210
   17924                                                              x1101110xx1xxxxx001000xxxxxxxxxx
   17925                                                              usubl2.  */
   17926                                                           return 81;
   17927                                                         }
   17928                                                     }
   17929                                                   else
   17930                                                     {
   17931                                                       if (((word >> 30) & 0x1) == 0)
   17932                                                         {
   17933                                                           /* 33222222222211111111110000000000
   17934                                                              10987654321098765432109876543210
   17935                                                              x0101110xx1xxxxx011000xxxxxxxxxx
   17936                                                              rsubhn.  */
   17937                                                           return 88;
   17938                                                         }
   17939                                                       else
   17940                                                         {
   17941                                                           /* 33222222222211111111110000000000
   17942                                                              10987654321098765432109876543210
   17943                                                              x1101110xx1xxxxx011000xxxxxxxxxx
   17944                                                              rsubhn2.  */
   17945                                                           return 89;
   17946                                                         }
   17947                                                     }
   17948                                                 }
   17949                                             }
   17950                                           else
   17951                                             {
   17952                                               if (((word >> 13) & 0x1) == 0)
   17953                                                 {
   17954                                                   if (((word >> 14) & 0x1) == 0)
   17955                                                     {
   17956                                                       if (((word >> 30) & 0x1) == 0)
   17957                                                         {
   17958                                                           /* 33222222222211111111110000000000
   17959                                                              10987654321098765432109876543210
   17960                                                              x0101110xx1xxxxx000100xxxxxxxxxx
   17961                                                              uaddw.  */
   17962                                                           return 78;
   17963                                                         }
   17964                                                       else
   17965                                                         {
   17966                                                           /* 33222222222211111111110000000000
   17967                                                              10987654321098765432109876543210
   17968                                                              x1101110xx1xxxxx000100xxxxxxxxxx
   17969                                                              uaddw2.  */
   17970                                                           return 79;
   17971                                                         }
   17972                                                     }
   17973                                                   else
   17974                                                     {
   17975                                                       if (((word >> 30) & 0x1) == 0)
   17976                                                         {
   17977                                                           /* 33222222222211111111110000000000
   17978                                                              10987654321098765432109876543210
   17979                                                              x0101110xx1xxxxx010100xxxxxxxxxx
   17980                                                              uabal.  */
   17981                                                           return 86;
   17982                                                         }
   17983                                                       else
   17984                                                         {
   17985                                                           /* 33222222222211111111110000000000
   17986                                                              10987654321098765432109876543210
   17987                                                              x1101110xx1xxxxx010100xxxxxxxxxx
   17988                                                              uabal2.  */
   17989                                                           return 87;
   17990                                                         }
   17991                                                     }
   17992                                                 }
   17993                                               else
   17994                                                 {
   17995                                                   if (((word >> 14) & 0x1) == 0)
   17996                                                     {
   17997                                                       if (((word >> 30) & 0x1) == 0)
   17998                                                         {
   17999                                                           /* 33222222222211111111110000000000
   18000                                                              10987654321098765432109876543210
   18001                                                              x0101110xx1xxxxx001100xxxxxxxxxx
   18002                                                              usubw.  */
   18003                                                           return 82;
   18004                                                         }
   18005                                                       else
   18006                                                         {
   18007                                                           /* 33222222222211111111110000000000
   18008                                                              10987654321098765432109876543210
   18009                                                              x1101110xx1xxxxx001100xxxxxxxxxx
   18010                                                              usubw2.  */
   18011                                                           return 83;
   18012                                                         }
   18013                                                     }
   18014                                                   else
   18015                                                     {
   18016                                                       if (((word >> 30) & 0x1) == 0)
   18017                                                         {
   18018                                                           /* 33222222222211111111110000000000
   18019                                                              10987654321098765432109876543210
   18020                                                              x0101110xx1xxxxx011100xxxxxxxxxx
   18021                                                              uabdl.  */
   18022                                                           return 90;
   18023                                                         }
   18024                                                       else
   18025                                                         {
   18026                                                           /* 33222222222211111111110000000000
   18027                                                              10987654321098765432109876543210
   18028                                                              x1101110xx1xxxxx011100xxxxxxxxxx
   18029                                                              uabdl2.  */
   18030                                                           return 91;
   18031                                                         }
   18032                                                     }
   18033                                                 }
   18034                                             }
   18035                                         }
   18036                                       else
   18037                                         {
   18038                                           if (((word >> 12) & 0x1) == 0)
   18039                                             {
   18040                                               if (((word >> 13) & 0x1) == 0)
   18041                                                 {
   18042                                                   if (((word >> 14) & 0x1) == 0)
   18043                                                     {
   18044                                                       /* 33222222222211111111110000000000
   18045                                                          10987654321098765432109876543210
   18046                                                          xx101110xx1xxxxx000010xxxxxxxxxx
   18047                                                          rev32.  */
   18048                                                       return 213;
   18049                                                     }
   18050                                                   else
   18051                                                     {
   18052                                                       if (((word >> 16) & 0x1) == 0)
   18053                                                         {
   18054                                                           /* 33222222222211111111110000000000
   18055                                                              10987654321098765432109876543210
   18056                                                              xx101110xx1xxxx0010010xxxxxxxxxx
   18057                                                              clz.  */
   18058                                                           return 216;
   18059                                                         }
   18060                                                       else
   18061                                                         {
   18062                                                           if (((word >> 30) & 0x1) == 0)
   18063                                                             {
   18064                                                               /* 33222222222211111111110000000000
   18065                                                                  10987654321098765432109876543210
   18066                                                                  x0101110xx1xxxx1010010xxxxxxxxxx
   18067                                                                  uqxtn.  */
   18068                                                               return 226;
   18069                                                             }
   18070                                                           else
   18071                                                             {
   18072                                                               /* 33222222222211111111110000000000
   18073                                                                  10987654321098765432109876543210
   18074                                                                  x1101110xx1xxxx1010010xxxxxxxxxx
   18075                                                                  uqxtn2.  */
   18076                                                               return 227;
   18077                                                             }
   18078                                                         }
   18079                                                     }
   18080                                                 }
   18081                                               else
   18082                                                 {
   18083                                                   if (((word >> 14) & 0x1) == 0)
   18084                                                     {
   18085                                                       if (((word >> 16) & 0x1) == 0)
   18086                                                         {
   18087                                                           /* 33222222222211111111110000000000
   18088                                                              10987654321098765432109876543210
   18089                                                              xx101110xx1xxxx0001010xxxxxxxxxx
   18090                                                              uaddlp.  */
   18091                                                           return 214;
   18092                                                         }
   18093                                                       else
   18094                                                         {
   18095                                                           if (((word >> 30) & 0x1) == 0)
   18096                                                             {
   18097                                                               /* 33222222222211111111110000000000
   18098                                                                  10987654321098765432109876543210
   18099                                                                  x0101110xx1xxxx1001010xxxxxxxxxx
   18100                                                                  sqxtun.  */
   18101                                                               return 222;
   18102                                                             }
   18103                                                           else
   18104                                                             {
   18105                                                               /* 33222222222211111111110000000000
   18106                                                                  10987654321098765432109876543210
   18107                                                                  x1101110xx1xxxx1001010xxxxxxxxxx
   18108                                                                  sqxtun2.  */
   18109                                                               return 223;
   18110                                                             }
   18111                                                         }
   18112                                                     }
   18113                                                   else
   18114                                                     {
   18115                                                       if (((word >> 16) & 0x1) == 0)
   18116                                                         {
   18117                                                           /* 33222222222211111111110000000000
   18118                                                              10987654321098765432109876543210
   18119                                                              xx101110xx1xxxx0011010xxxxxxxxxx
   18120                                                              uadalp.  */
   18121                                                           return 217;
   18122                                                         }
   18123                                                       else
   18124                                                         {
   18125                                                           if (((word >> 30) & 0x1) == 0)
   18126                                                             {
   18127                                                               /* 33222222222211111111110000000000
   18128                                                                  10987654321098765432109876543210
   18129                                                                  x0101110xx1xxxx1011010xxxxxxxxxx
   18130                                                                  fcvtxn.  */
   18131                                                               return 228;
   18132                                                             }
   18133                                                           else
   18134                                                             {
   18135                                                               /* 33222222222211111111110000000000
   18136                                                                  10987654321098765432109876543210
   18137                                                                  x1101110xx1xxxx1011010xxxxxxxxxx
   18138                                                                  fcvtxn2.  */
   18139                                                               return 229;
   18140                                                             }
   18141                                                         }
   18142                                                     }
   18143                                                 }
   18144                                             }
   18145                                           else
   18146                                             {
   18147                                               if (((word >> 13) & 0x1) == 0)
   18148                                                 {
   18149                                                   if (((word >> 22) & 0x1) == 0)
   18150                                                     {
   18151                                                       /* 33222222222211111111110000000000
   18152                                                          10987654321098765432109876543210
   18153                                                          xx101110x01xxxxx0x0110xxxxxxxxxx
   18154                                                          not.  */
   18155                                                       return 242;
   18156                                                     }
   18157                                                   else
   18158                                                     {
   18159                                                       /* 33222222222211111111110000000000
   18160                                                          10987654321098765432109876543210
   18161                                                          xx101110x11xxxxx0x0110xxxxxxxxxx
   18162                                                          rbit.  */
   18163                                                       return 244;
   18164                                                     }
   18165                                                 }
   18166                                               else
   18167                                                 {
   18168                                                   if (((word >> 14) & 0x1) == 0)
   18169                                                     {
   18170                                                       if (((word >> 16) & 0x1) == 0)
   18171                                                         {
   18172                                                           if (((word >> 20) & 0x1) == 0)
   18173                                                             {
   18174                                                               /* 33222222222211111111110000000000
   18175                                                                  10987654321098765432109876543210
   18176                                                                  xx101110xx10xxx0001110xxxxxxxxxx
   18177                                                                  usqadd.  */
   18178                                                               return 215;
   18179                                                             }
   18180                                                           else
   18181                                                             {
   18182                                                               /* 33222222222211111111110000000000
   18183                                                                  10987654321098765432109876543210
   18184                                                                  xx101110xx11xxx0001110xxxxxxxxxx
   18185                                                                  uaddlv.  */
   18186                                                               return 33;
   18187                                                             }
   18188                                                         }
   18189                                                       else
   18190                                                         {
   18191                                                           if (((word >> 30) & 0x1) == 0)
   18192                                                             {
   18193                                                               /* 33222222222211111111110000000000
   18194                                                                  10987654321098765432109876543210
   18195                                                                  x0101110xx1xxxx1001110xxxxxxxxxx
   18196                                                                  shll.  */
   18197                                                               return 224;
   18198                                                             }
   18199                                                           else
   18200                                                             {
   18201                                                               /* 33222222222211111111110000000000
   18202                                                                  10987654321098765432109876543210
   18203                                                                  x1101110xx1xxxx1001110xxxxxxxxxx
   18204                                                                  shll2.  */
   18205                                                               return 225;
   18206                                                             }
   18207                                                         }
   18208                                                     }
   18209                                                   else
   18210                                                     {
   18211                                                       /* 33222222222211111111110000000000
   18212                                                          10987654321098765432109876543210
   18213                                                          xx101110xx1xxxxx011110xxxxxxxxxx
   18214                                                          sqneg.  */
   18215                                                       return 218;
   18216                                                     }
   18217                                                 }
   18218                                             }
   18219                                         }
   18220                                     }
   18221                                   else
   18222                                     {
   18223                                       if (((word >> 11) & 0x1) == 0)
   18224                                         {
   18225                                           if (((word >> 12) & 0x1) == 0)
   18226                                             {
   18227                                               if (((word >> 13) & 0x1) == 0)
   18228                                                 {
   18229                                                   if (((word >> 14) & 0x1) == 0)
   18230                                                     {
   18231                                                       /* 33222222222211111111110000000000
   18232                                                          10987654321098765432109876543210
   18233                                                          xx101110xx1xxxxx000001xxxxxxxxxx
   18234                                                          uhadd.  */
   18235                                                       return 320;
   18236                                                     }
   18237                                                   else
   18238                                                     {
   18239                                                       /* 33222222222211111111110000000000
   18240                                                          10987654321098765432109876543210
   18241                                                          xx101110xx1xxxxx010001xxxxxxxxxx
   18242                                                          ushl.  */
   18243                                                       return 327;
   18244                                                     }
   18245                                                 }
   18246                                               else
   18247                                                 {
   18248                                                   if (((word >> 14) & 0x1) == 0)
   18249                                                     {
   18250                                                       /* 33222222222211111111110000000000
   18251                                                          10987654321098765432109876543210
   18252                                                          xx101110xx1xxxxx001001xxxxxxxxxx
   18253                                                          uhsub.  */
   18254                                                       return 323;
   18255                                                     }
   18256                                                   else
   18257                                                     {
   18258                                                       /* 33222222222211111111110000000000
   18259                                                          10987654321098765432109876543210
   18260                                                          xx101110xx1xxxxx011001xxxxxxxxxx
   18261                                                          umax.  */
   18262                                                       return 331;
   18263                                                     }
   18264                                                 }
   18265                                             }
   18266                                           else
   18267                                             {
   18268                                               if (((word >> 13) & 0x1) == 0)
   18269                                                 {
   18270                                                   if (((word >> 14) & 0x1) == 0)
   18271                                                     {
   18272                                                       /* 33222222222211111111110000000000
   18273                                                          10987654321098765432109876543210
   18274                                                          xx101110xx1xxxxx000101xxxxxxxxxx
   18275                                                          urhadd.  */
   18276                                                       return 322;
   18277                                                     }
   18278                                                   else
   18279                                                     {
   18280                                                       /* 33222222222211111111110000000000
   18281                                                          10987654321098765432109876543210
   18282                                                          xx101110xx1xxxxx010101xxxxxxxxxx
   18283                                                          urshl.  */
   18284                                                       return 329;
   18285                                                     }
   18286                                                 }
   18287                                               else
   18288                                                 {
   18289                                                   if (((word >> 14) & 0x1) == 0)
   18290                                                     {
   18291                                                       /* 33222222222211111111110000000000
   18292                                                          10987654321098765432109876543210
   18293                                                          xx101110xx1xxxxx001101xxxxxxxxxx
   18294                                                          cmhi.  */
   18295                                                       return 325;
   18296                                                     }
   18297                                                   else
   18298                                                     {
   18299                                                       /* 33222222222211111111110000000000
   18300                                                          10987654321098765432109876543210
   18301                                                          xx101110xx1xxxxx011101xxxxxxxxxx
   18302                                                          uabd.  */
   18303                                                       return 333;
   18304                                                     }
   18305                                                 }
   18306                                             }
   18307                                         }
   18308                                       else
   18309                                         {
   18310                                           if (((word >> 12) & 0x1) == 0)
   18311                                             {
   18312                                               if (((word >> 13) & 0x1) == 0)
   18313                                                 {
   18314                                                   if (((word >> 14) & 0x1) == 0)
   18315                                                     {
   18316                                                       /* 33222222222211111111110000000000
   18317                                                          10987654321098765432109876543210
   18318                                                          xx101110xx1xxxxx000011xxxxxxxxxx
   18319                                                          uqadd.  */
   18320                                                       return 321;
   18321                                                     }
   18322                                                   else
   18323                                                     {
   18324                                                       /* 33222222222211111111110000000000
   18325                                                          10987654321098765432109876543210
   18326                                                          xx101110xx1xxxxx010011xxxxxxxxxx
   18327                                                          uqshl.  */
   18328                                                       return 328;
   18329                                                     }
   18330                                                 }
   18331                                               else
   18332                                                 {
   18333                                                   if (((word >> 14) & 0x1) == 0)
   18334                                                     {
   18335                                                       /* 33222222222211111111110000000000
   18336                                                          10987654321098765432109876543210
   18337                                                          xx101110xx1xxxxx001011xxxxxxxxxx
   18338                                                          uqsub.  */
   18339                                                       return 324;
   18340                                                     }
   18341                                                   else
   18342                                                     {
   18343                                                       /* 33222222222211111111110000000000
   18344                                                          10987654321098765432109876543210
   18345                                                          xx101110xx1xxxxx011011xxxxxxxxxx
   18346                                                          umin.  */
   18347                                                       return 332;
   18348                                                     }
   18349                                                 }
   18350                                             }
   18351                                           else
   18352                                             {
   18353                                               if (((word >> 13) & 0x1) == 0)
   18354                                                 {
   18355                                                   if (((word >> 14) & 0x1) == 0)
   18356                                                     {
   18357                                                       if (((word >> 22) & 0x1) == 0)
   18358                                                         {
   18359                                                           if (((word >> 23) & 0x1) == 0)
   18360                                                             {
   18361                                                               /* 33222222222211111111110000000000
   18362                                                                  10987654321098765432109876543210
   18363                                                                  xx101110001xxxxx000111xxxxxxxxxx
   18364                                                                  eor.  */
   18365                                                               return 356;
   18366                                                             }
   18367                                                           else
   18368                                                             {
   18369                                                               /* 33222222222211111111110000000000
   18370                                                                  10987654321098765432109876543210
   18371                                                                  xx101110101xxxxx000111xxxxxxxxxx
   18372                                                                  bit.  */
   18373                                                               return 368;
   18374                                                             }
   18375                                                         }
   18376                                                       else
   18377                                                         {
   18378                                                           if (((word >> 23) & 0x1) == 0)
   18379                                                             {
   18380                                                               /* 33222222222211111111110000000000
   18381                                                                  10987654321098765432109876543210
   18382                                                                  xx101110011xxxxx000111xxxxxxxxxx
   18383                                                                  bsl.  */
   18384                                                               return 357;
   18385                                                             }
   18386                                                           else
   18387                                                             {
   18388                                                               /* 33222222222211111111110000000000
   18389                                                                  10987654321098765432109876543210
   18390                                                                  xx101110111xxxxx000111xxxxxxxxxx
   18391                                                                  bif.  */
   18392                                                               return 369;
   18393                                                             }
   18394                                                         }
   18395                                                     }
   18396                                                   else
   18397                                                     {
   18398                                                       /* 33222222222211111111110000000000
   18399                                                          10987654321098765432109876543210
   18400                                                          xx101110xx1xxxxx010111xxxxxxxxxx
   18401                                                          uqrshl.  */
   18402                                                       return 330;
   18403                                                     }
   18404                                                 }
   18405                                               else
   18406                                                 {
   18407                                                   if (((word >> 14) & 0x1) == 0)
   18408                                                     {
   18409                                                       /* 33222222222211111111110000000000
   18410                                                          10987654321098765432109876543210
   18411                                                          xx101110xx1xxxxx001111xxxxxxxxxx
   18412                                                          cmhs.  */
   18413                                                       return 326;
   18414                                                     }
   18415                                                   else
   18416                                                     {
   18417                                                       /* 33222222222211111111110000000000
   18418                                                          10987654321098765432109876543210
   18419                                                          xx101110xx1xxxxx011111xxxxxxxxxx
   18420                                                          uaba.  */
   18421                                                       return 334;
   18422                                                     }
   18423                                                 }
   18424                                             }
   18425                                         }
   18426                                     }
   18427                                 }
   18428                             }
   18429                           else
   18430                             {
   18431                               if (((word >> 10) & 0x1) == 0)
   18432                                 {
   18433                                   if (((word >> 11) & 0x1) == 0)
   18434                                     {
   18435                                       if (((word >> 12) & 0x1) == 0)
   18436                                         {
   18437                                           if (((word >> 13) & 0x1) == 0)
   18438                                             {
   18439                                               if (((word >> 14) & 0x1) == 0)
   18440                                                 {
   18441                                                   if (((word >> 29) & 0x1) == 0)
   18442                                                     {
   18443                                                       if (((word >> 30) & 0x1) == 0)
   18444                                                         {
   18445                                                           /* 33222222222211111111110000000000
   18446                                                              10987654321098765432109876543210
   18447                                                              x0001110xx1xxxxx100000xxxxxxxxxx
   18448                                                              smlal.  */
   18449                                                           return 60;
   18450                                                         }
   18451                                                       else
   18452                                                         {
   18453                                                           if (((word >> 31) & 0x1) == 0)
   18454                                                             {
   18455                                                               /* 33222222222211111111110000000000
   18456                                                                  10987654321098765432109876543210
   18457                                                                  01001110xx1xxxxx100000xxxxxxxxxx
   18458                                                                  smlal2.  */
   18459                                                               return 61;
   18460                                                             }
   18461                                                           else
   18462                                                             {
   18463                                                               /* 33222222222211111111110000000000
   18464                                                                  10987654321098765432109876543210
   18465                                                                  11001110xx1xxxxx100000xxxxxxxxxx
   18466                                                                  sha512h.  */
   18467                                                               return 2345;
   18468                                                             }
   18469                                                         }
   18470                                                     }
   18471                                                   else
   18472                                                     {
   18473                                                       if (((word >> 30) & 0x1) == 0)
   18474                                                         {
   18475                                                           /* 33222222222211111111110000000000
   18476                                                              10987654321098765432109876543210
   18477                                                              x0101110xx1xxxxx100000xxxxxxxxxx
   18478                                                              umlal.  */
   18479                                                           return 92;
   18480                                                         }
   18481                                                       else
   18482                                                         {
   18483                                                           /* 33222222222211111111110000000000
   18484                                                              10987654321098765432109876543210
   18485                                                              x1101110xx1xxxxx100000xxxxxxxxxx
   18486                                                              umlal2.  */
   18487                                                           return 93;
   18488                                                         }
   18489                                                     }
   18490                                                 }
   18491                                               else
   18492                                                 {
   18493                                                   if (((word >> 29) & 0x1) == 0)
   18494                                                     {
   18495                                                       if (((word >> 30) & 0x1) == 0)
   18496                                                         {
   18497                                                           /* 33222222222211111111110000000000
   18498                                                              10987654321098765432109876543210
   18499                                                              x0001110xx1xxxxx110000xxxxxxxxxx
   18500                                                              smull.  */
   18501                                                           return 68;
   18502                                                         }
   18503                                                       else
   18504                                                         {
   18505                                                           if (((word >> 31) & 0x1) == 0)
   18506                                                             {
   18507                                                               /* 33222222222211111111110000000000
   18508                                                                  10987654321098765432109876543210
   18509                                                                  01001110xx1xxxxx110000xxxxxxxxxx
   18510                                                                  smull2.  */
   18511                                                               return 69;
   18512                                                             }
   18513                                                           else
   18514                                                             {
   18515                                                               /* 33222222222211111111110000000000
   18516                                                                  10987654321098765432109876543210
   18517                                                                  11001110xx1xxxxx110000xxxxxxxxxx
   18518                                                                  sm3partw1.  */
   18519                                                               return 2358;
   18520                                                             }
   18521                                                         }
   18522                                                     }
   18523                                                   else
   18524                                                     {
   18525                                                       if (((word >> 30) & 0x1) == 0)
   18526                                                         {
   18527                                                           /* 33222222222211111111110000000000
   18528                                                              10987654321098765432109876543210
   18529                                                              x0101110xx1xxxxx110000xxxxxxxxxx
   18530                                                              umull.  */
   18531                                                           return 96;
   18532                                                         }
   18533                                                       else
   18534                                                         {
   18535                                                           /* 33222222222211111111110000000000
   18536                                                              10987654321098765432109876543210
   18537                                                              x1101110xx1xxxxx110000xxxxxxxxxx
   18538                                                              umull2.  */
   18539                                                           return 97;
   18540                                                         }
   18541                                                     }
   18542                                                 }
   18543                                             }
   18544                                           else
   18545                                             {
   18546                                               if (((word >> 14) & 0x1) == 0)
   18547                                                 {
   18548                                                   if (((word >> 29) & 0x1) == 0)
   18549                                                     {
   18550                                                       if (((word >> 30) & 0x1) == 0)
   18551                                                         {
   18552                                                           /* 33222222222211111111110000000000
   18553                                                              10987654321098765432109876543210
   18554                                                              x0001110xx1xxxxx101000xxxxxxxxxx
   18555                                                              smlsl.  */
   18556                                                           return 64;
   18557                                                         }
   18558                                                       else
   18559                                                         {
   18560                                                           /* 33222222222211111111110000000000
   18561                                                              10987654321098765432109876543210
   18562                                                              x1001110xx1xxxxx101000xxxxxxxxxx
   18563                                                              smlsl2.  */
   18564                                                           return 65;
   18565                                                         }
   18566                                                     }
   18567                                                   else
   18568                                                     {
   18569                                                       if (((word >> 30) & 0x1) == 0)
   18570                                                         {
   18571                                                           /* 33222222222211111111110000000000
   18572                                                              10987654321098765432109876543210
   18573                                                              x0101110xx1xxxxx101000xxxxxxxxxx
   18574                                                              umlsl.  */
   18575                                                           return 94;
   18576                                                         }
   18577                                                       else
   18578                                                         {
   18579                                                           /* 33222222222211111111110000000000
   18580                                                              10987654321098765432109876543210
   18581                                                              x1101110xx1xxxxx101000xxxxxxxxxx
   18582                                                              umlsl2.  */
   18583                                                           return 95;
   18584                                                         }
   18585                                                     }
   18586                                                 }
   18587                                               else
   18588                                                 {
   18589                                                   if (((word >> 22) & 0x1) == 0)
   18590                                                     {
   18591                                                       if (((word >> 30) & 0x1) == 0)
   18592                                                         {
   18593                                                           /* 33222222222211111111110000000000
   18594                                                              10987654321098765432109876543210
   18595                                                              x0x01110x01xxxxx111000xxxxxxxxxx
   18596                                                              pmull.  */
   18597                                                           return 72;
   18598                                                         }
   18599                                                       else
   18600                                                         {
   18601                                                           /* 33222222222211111111110000000000
   18602                                                              10987654321098765432109876543210
   18603                                                              x1x01110x01xxxxx111000xxxxxxxxxx
   18604                                                              pmull2.  */
   18605                                                           return 74;
   18606                                                         }
   18607                                                     }
   18608                                                   else
   18609                                                     {
   18610                                                       if (((word >> 30) & 0x1) == 0)
   18611                                                         {
   18612                                                           /* 33222222222211111111110000000000
   18613                                                              10987654321098765432109876543210
   18614                                                              x0x01110x11xxxxx111000xxxxxxxxxx
   18615                                                              pmull.  */
   18616                                                           return 73;
   18617                                                         }
   18618                                                       else
   18619                                                         {
   18620                                                           /* 33222222222211111111110000000000
   18621                                                              10987654321098765432109876543210
   18622                                                              x1x01110x11xxxxx111000xxxxxxxxxx
   18623                                                              pmull2.  */
   18624                                                           return 75;
   18625                                                         }
   18626                                                     }
   18627                                                 }
   18628                                             }
   18629                                         }
   18630                                       else
   18631                                         {
   18632                                           if (((word >> 13) & 0x1) == 0)
   18633                                             {
   18634                                               if (((word >> 14) & 0x1) == 0)
   18635                                                 {
   18636                                                   if (((word >> 30) & 0x1) == 0)
   18637                                                     {
   18638                                                       /* 33222222222211111111110000000000
   18639                                                          10987654321098765432109876543210
   18640                                                          x0x01110xx1xxxxx100100xxxxxxxxxx
   18641                                                          sqdmlal.  */
   18642                                                       return 62;
   18643                                                     }
   18644                                                   else
   18645                                                     {
   18646                                                       /* 33222222222211111111110000000000
   18647                                                          10987654321098765432109876543210
   18648                                                          x1x01110xx1xxxxx100100xxxxxxxxxx
   18649                                                          sqdmlal2.  */
   18650                                                       return 63;
   18651                                                     }
   18652                                                 }
   18653                                               else
   18654                                                 {
   18655                                                   if (((word >> 30) & 0x1) == 0)
   18656                                                     {
   18657                                                       /* 33222222222211111111110000000000
   18658                                                          10987654321098765432109876543210
   18659                                                          x0x01110xx1xxxxx110100xxxxxxxxxx
   18660                                                          sqdmull.  */
   18661                                                       return 70;
   18662                                                     }
   18663                                                   else
   18664                                                     {
   18665                                                       /* 33222222222211111111110000000000
   18666                                                          10987654321098765432109876543210
   18667                                                          x1x01110xx1xxxxx110100xxxxxxxxxx
   18668                                                          sqdmull2.  */
   18669                                                       return 71;
   18670                                                     }
   18671                                                 }
   18672                                             }
   18673                                           else
   18674                                             {
   18675                                               if (((word >> 30) & 0x1) == 0)
   18676                                                 {
   18677                                                   /* 33222222222211111111110000000000
   18678                                                      10987654321098765432109876543210
   18679                                                      x0x01110xx1xxxxx1x1100xxxxxxxxxx
   18680                                                      sqdmlsl.  */
   18681                                                   return 66;
   18682                                                 }
   18683                                               else
   18684                                                 {
   18685                                                   /* 33222222222211111111110000000000
   18686                                                      10987654321098765432109876543210
   18687                                                      x1x01110xx1xxxxx1x1100xxxxxxxxxx
   18688                                                      sqdmlsl2.  */
   18689                                                   return 67;
   18690                                                 }
   18691                                             }
   18692                                         }
   18693                                     }
   18694                                   else
   18695                                     {
   18696                                       if (((word >> 12) & 0x1) == 0)
   18697                                         {
   18698                                           if (((word >> 13) & 0x1) == 0)
   18699                                             {
   18700                                               if (((word >> 14) & 0x1) == 0)
   18701                                                 {
   18702                                                   if (((word >> 29) & 0x1) == 0)
   18703                                                     {
   18704                                                       if (((word >> 31) & 0x1) == 0)
   18705                                                         {
   18706                                                           if (((word >> 16) & 0x1) == 0)
   18707                                                             {
   18708                                                               /* 33222222222211111111110000000000
   18709                                                                  10987654321098765432109876543210
   18710                                                                  0x001110xx1xxxx0100010xxxxxxxxxx
   18711                                                                  cmgt.  */
   18712                                                               return 170;
   18713                                                             }
   18714                                                           else
   18715                                                             {
   18716                                                               if (((word >> 19) & 0x1) == 0)
   18717                                                                 {
   18718                                                                   if (((word >> 23) & 0x1) == 0)
   18719                                                                     {
   18720                                                                       /* 33222222222211111111110000000000
   18721                                                                          10987654321098765432109876543210
   18722                                                                          0x0011100x1x0xx1100010xxxxxxxxxx
   18723                                                                          frintn.  */
   18724                                                                       return 182;
   18725                                                                     }
   18726                                                                   else
   18727                                                                     {
   18728                                                                       /* 33222222222211111111110000000000
   18729                                                                          10987654321098765432109876543210
   18730                                                                          0x0011101x1x0xx1100010xxxxxxxxxx
   18731                                                                          frintp.  */
   18732                                                                       return 202;
   18733                                                                     }
   18734                                                                 }
   18735                                                               else
   18736                                                                 {
   18737                                                                   if (((word >> 23) & 0x1) == 0)
   18738                                                                     {
   18739                                                                       /* 33222222222211111111110000000000
   18740                                                                          10987654321098765432109876543210
   18741                                                                          0x0011100x1x1xx1100010xxxxxxxxxx
   18742                                                                          frintn.  */
   18743                                                                       return 183;
   18744                                                                     }
   18745                                                                   else
   18746                                                                     {
   18747                                                                       /* 33222222222211111111110000000000
   18748                                                                          10987654321098765432109876543210
   18749                                                                          0x0011101x1x1xx1100010xxxxxxxxxx
   18750                                                                          frintp.  */
   18751                                                                       return 203;
   18752                                                                     }
   18753                                                                 }
   18754                                                             }
   18755                                                         }
   18756                                                       else
   18757                                                         {
   18758                                                           /* 33222222222211111111110000000000
   18759                                                              10987654321098765432109876543210
   18760                                                              1x001110xx1xxxxx100010xxxxxxxxxx
   18761                                                              sha512su1.  */
   18762                                                           return 2348;
   18763                                                         }
   18764                                                     }
   18765                                                   else
   18766                                                     {
   18767                                                       if (((word >> 16) & 0x1) == 0)
   18768                                                         {
   18769                                                           /* 33222222222211111111110000000000
   18770                                                              10987654321098765432109876543210
   18771                                                              xx101110xx1xxxx0100010xxxxxxxxxx
   18772                                                              cmge.  */
   18773                                                           return 219;
   18774                                                         }
   18775                                                       else
   18776                                                         {
   18777                                                           if (((word >> 19) & 0x1) == 0)
   18778                                                             {
   18779                                                               /* 33222222222211111111110000000000
   18780                                                                  10987654321098765432109876543210
   18781                                                                  xx101110xx1x0xx1100010xxxxxxxxxx
   18782                                                                  frinta.  */
   18783                                                               return 230;
   18784                                                             }
   18785                                                           else
   18786                                                             {
   18787                                                               /* 33222222222211111111110000000000
   18788                                                                  10987654321098765432109876543210
   18789                                                                  xx101110xx1x1xx1100010xxxxxxxxxx
   18790                                                                  frinta.  */
   18791                                                               return 231;
   18792                                                             }
   18793                                                         }
   18794                                                     }
   18795                                                 }
   18796                                               else
   18797                                                 {
   18798                                                   if (((word >> 23) & 0x1) == 0)
   18799                                                     {
   18800                                                       if (((word >> 29) & 0x1) == 0)
   18801                                                         {
   18802                                                           if (((word >> 31) & 0x1) == 0)
   18803                                                             {
   18804                                                               if (((word >> 16) & 0x1) == 0)
   18805                                                                 {
   18806                                                                   /* 33222222222211111111110000000000
   18807                                                                      10987654321098765432109876543210
   18808                                                                      0x0011100x1xxxx0110010xxxxxxxxxx
   18809                                                                      fmaxnmv.  */
   18810                                                                   return 37;
   18811                                                                 }
   18812                                                               else
   18813                                                                 {
   18814                                                                   if (((word >> 19) & 0x1) == 0)
   18815                                                                     {
   18816                                                                       /* 33222222222211111111110000000000
   18817                                                                          10987654321098765432109876543210
   18818                                                                          0x0011100x1x0xx1110010xxxxxxxxxx
   18819                                                                          fcvtas.  */
   18820                                                                       return 190;
   18821                                                                     }
   18822                                                                   else
   18823                                                                     {
   18824                                                                       /* 33222222222211111111110000000000
   18825                                                                          10987654321098765432109876543210
   18826                                                                          0x0011100x1x1xx1110010xxxxxxxxxx
   18827                                                                          fcvtas.  */
   18828                                                                       return 191;
   18829                                                                     }
   18830                                                                 }
   18831                                                             }
   18832                                                           else
   18833                                                             {
   18834                                                               /* 33222222222211111111110000000000
   18835                                                                  10987654321098765432109876543210
   18836                                                                  1x0011100x1xxxxx110010xxxxxxxxxx
   18837                                                                  sm4ekey.  */
   18838                                                               return 2361;
   18839                                                             }
   18840                                                         }
   18841                                                       else
   18842                                                         {
   18843                                                           if (((word >> 16) & 0x1) == 0)
   18844                                                             {
   18845                                                               /* 33222222222211111111110000000000
   18846                                                                  10987654321098765432109876543210
   18847                                                                  xx1011100x1xxxx0110010xxxxxxxxxx
   18848                                                                  fmaxnmv.  */
   18849                                                               return 36;
   18850                                                             }
   18851                                                           else
   18852                                                             {
   18853                                                               if (((word >> 19) & 0x1) == 0)
   18854                                                                 {
   18855                                                                   /* 33222222222211111111110000000000
   18856                                                                      10987654321098765432109876543210
   18857                                                                      xx1011100x1x0xx1110010xxxxxxxxxx
   18858                                                                      fcvtau.  */
   18859                                                                   return 238;
   18860                                                                 }
   18861                                                               else
   18862                                                                 {
   18863                                                                   /* 33222222222211111111110000000000
   18864                                                                      10987654321098765432109876543210
   18865                                                                      xx1011100x1x1xx1110010xxxxxxxxxx
   18866                                                                      fcvtau.  */
   18867                                                                   return 239;
   18868                                                                 }
   18869                                                             }
   18870                                                         }
   18871                                                     }
   18872                                                   else
   18873                                                     {
   18874                                                       if (((word >> 16) & 0x1) == 0)
   18875                                                         {
   18876                                                           if (((word >> 19) & 0x1) == 0)
   18877                                                             {
   18878                                                               if (((word >> 20) & 0x1) == 0)
   18879                                                                 {
   18880                                                                   if (((word >> 29) & 0x1) == 0)
   18881                                                                     {
   18882                                                                       /* 33222222222211111111110000000000
   18883                                                                          10987654321098765432109876543210
   18884                                                                          xx0011101x100xx0110010xxxxxxxxxx
   18885                                                                          fcmgt.  */
   18886                                                                       return 194;
   18887                                                                     }
   18888                                                                   else
   18889                                                                     {
   18890                                                                       /* 33222222222211111111110000000000
   18891                                                                          10987654321098765432109876543210
   18892                                                                          xx1011101x100xx0110010xxxxxxxxxx
   18893                                                                          fcmge.  */
   18894                                                                       return 245;
   18895                                                                     }
   18896                                                                 }
   18897                                                               else
   18898                                                                 {
   18899                                                                   if (((word >> 29) & 0x1) == 0)
   18900                                                                     {
   18901                                                                       /* 33222222222211111111110000000000
   18902                                                                          10987654321098765432109876543210
   18903                                                                          xx0011101x110xx0110010xxxxxxxxxx
   18904                                                                          fminnmv.  */
   18905                                                                       return 41;
   18906                                                                     }
   18907                                                                   else
   18908                                                                     {
   18909                                                                       /* 33222222222211111111110000000000
   18910                                                                          10987654321098765432109876543210
   18911                                                                          xx1011101x110xx0110010xxxxxxxxxx
   18912                                                                          fminnmv.  */
   18913                                                                       return 40;
   18914                                                                     }
   18915                                                                 }
   18916                                                             }
   18917                                                           else
   18918                                                             {
   18919                                                               if (((word >> 29) & 0x1) == 0)
   18920                                                                 {
   18921                                                                   /* 33222222222211111111110000000000
   18922                                                                      10987654321098765432109876543210
   18923                                                                      xx0011101x1x1xx0110010xxxxxxxxxx
   18924                                                                      fcmgt.  */
   18925                                                                   return 195;
   18926                                                                 }
   18927                                                               else
   18928                                                                 {
   18929                                                                   /* 33222222222211111111110000000000
   18930                                                                      10987654321098765432109876543210
   18931                                                                      xx1011101x1x1xx0110010xxxxxxxxxx
   18932                                                                      fcmge.  */
   18933                                                                   return 246;
   18934                                                                 }
   18935                                                             }
   18936                                                         }
   18937                                                       else
   18938                                                         {
   18939                                                           if (((word >> 29) & 0x1) == 0)
   18940                                                             {
   18941                                                               /* 33222222222211111111110000000000
   18942                                                                  10987654321098765432109876543210
   18943                                                                  xx0011101x1xxxx1110010xxxxxxxxxx
   18944                                                                  urecpe.  */
   18945                                                               return 210;
   18946                                                             }
   18947                                                           else
   18948                                                             {
   18949                                                               /* 33222222222211111111110000000000
   18950                                                                  10987654321098765432109876543210
   18951                                                                  xx1011101x1xxxx1110010xxxxxxxxxx
   18952                                                                  ursqrte.  */
   18953                                                               return 257;
   18954                                                             }
   18955                                                         }
   18956                                                     }
   18957                                                 }
   18958                                             }
   18959                                           else
   18960                                             {
   18961                                               if (((word >> 14) & 0x1) == 0)
   18962                                                 {
   18963                                                   if (((word >> 16) & 0x1) == 0)
   18964                                                     {
   18965                                                       if (((word >> 20) & 0x1) == 0)
   18966                                                         {
   18967                                                           /* 33222222222211111111110000000000
   18968                                                              10987654321098765432109876543210
   18969                                                              xxx01110xx10xxx0101010xxxxxxxxxx
   18970                                                              cmlt.  */
   18971                                                           return 172;
   18972                                                         }
   18973                                                       else
   18974                                                         {
   18975                                                           if (((word >> 29) & 0x1) == 0)
   18976                                                             {
   18977                                                               /* 33222222222211111111110000000000
   18978                                                                  10987654321098765432109876543210
   18979                                                                  xx001110xx11xxx0101010xxxxxxxxxx
   18980                                                                  smaxv.  */
   18981                                                               return 30;
   18982                                                             }
   18983                                                           else
   18984                                                             {
   18985                                                               /* 33222222222211111111110000000000
   18986                                                                  10987654321098765432109876543210
   18987                                                                  xx101110xx11xxx0101010xxxxxxxxxx
   18988                                                                  umaxv.  */
   18989                                                               return 34;
   18990                                                             }
   18991                                                         }
   18992                                                     }
   18993                                                   else
   18994                                                     {
   18995                                                       if (((word >> 19) & 0x1) == 0)
   18996                                                         {
   18997                                                           if (((word >> 20) & 0x1) == 0)
   18998                                                             {
   18999                                                               if (((word >> 23) & 0x1) == 0)
   19000                                                                 {
   19001                                                                   if (((word >> 29) & 0x1) == 0)
   19002                                                                     {
   19003                                                                       /* 33222222222211111111110000000000
   19004                                                                          10987654321098765432109876543210
   19005                                                                          xx0011100x100xx1101010xxxxxxxxxx
   19006                                                                          fcvtns.  */
   19007                                                                       return 186;
   19008                                                                     }
   19009                                                                   else
   19010                                                                     {
   19011                                                                       /* 33222222222211111111110000000000
   19012                                                                          10987654321098765432109876543210
   19013                                                                          xx1011100x100xx1101010xxxxxxxxxx
   19014                                                                          fcvtnu.  */
   19015                                                                       return 234;
   19016                                                                     }
   19017                                                                 }
   19018                                                               else
   19019                                                                 {
   19020                                                                   if (((word >> 29) & 0x1) == 0)
   19021                                                                     {
   19022                                                                       /* 33222222222211111111110000000000
   19023                                                                          10987654321098765432109876543210
   19024                                                                          xx0011101x100xx1101010xxxxxxxxxx
   19025                                                                          fcvtps.  */
   19026                                                                       return 206;
   19027                                                                     }
   19028                                                                   else
   19029                                                                     {
   19030                                                                       /* 33222222222211111111110000000000
   19031                                                                          10987654321098765432109876543210
   19032                                                                          xx1011101x100xx1101010xxxxxxxxxx
   19033                                                                          fcvtpu.  */
   19034                                                                       return 253;
   19035                                                                     }
   19036                                                                 }
   19037                                                             }
   19038                                                           else
   19039                                                             {
   19040                                                               if (((word >> 29) & 0x1) == 0)
   19041                                                                 {
   19042                                                                   /* 33222222222211111111110000000000
   19043                                                                      10987654321098765432109876543210
   19044                                                                      xx001110xx110xx1101010xxxxxxxxxx
   19045                                                                      sminv.  */
   19046                                                                   return 31;
   19047                                                                 }
   19048                                                               else
   19049                                                                 {
   19050                                                                   /* 33222222222211111111110000000000
   19051                                                                      10987654321098765432109876543210
   19052                                                                      xx101110xx110xx1101010xxxxxxxxxx
   19053                                                                      uminv.  */
   19054                                                                   return 35;
   19055                                                                 }
   19056                                                             }
   19057                                                         }
   19058                                                       else
   19059                                                         {
   19060                                                           if (((word >> 23) & 0x1) == 0)
   19061                                                             {
   19062                                                               if (((word >> 29) & 0x1) == 0)
   19063                                                                 {
   19064                                                                   /* 33222222222211111111110000000000
   19065                                                                      10987654321098765432109876543210
   19066                                                                      xx0011100x1x1xx1101010xxxxxxxxxx
   19067                                                                      fcvtns.  */
   19068                                                                   return 187;
   19069                                                                 }
   19070                                                               else
   19071                                                                 {
   19072                                                                   /* 33222222222211111111110000000000
   19073                                                                      10987654321098765432109876543210
   19074                                                                      xx1011100x1x1xx1101010xxxxxxxxxx
   19075                                                                      fcvtnu.  */
   19076                                                                   return 235;
   19077                                                                 }
   19078                                                             }
   19079                                                           else
   19080                                                             {
   19081                                                               if (((word >> 29) & 0x1) == 0)
   19082                                                                 {
   19083                                                                   /* 33222222222211111111110000000000
   19084                                                                      10987654321098765432109876543210
   19085                                                                      xx0011101x1x1xx1101010xxxxxxxxxx
   19086                                                                      fcvtps.  */
   19087                                                                   return 207;
   19088                                                                 }
   19089                                                               else
   19090                                                                 {
   19091                                                                   /* 33222222222211111111110000000000
   19092                                                                      10987654321098765432109876543210
   19093                                                                      xx1011101x1x1xx1101010xxxxxxxxxx
   19094                                                                      fcvtpu.  */
   19095                                                                   return 254;
   19096                                                                 }
   19097                                                             }
   19098                                                         }
   19099                                                     }
   19100                                                 }
   19101                                               else
   19102                                                 {
   19103                                                   if (((word >> 16) & 0x1) == 0)
   19104                                                     {
   19105                                                       if (((word >> 19) & 0x1) == 0)
   19106                                                         {
   19107                                                           /* 33222222222211111111110000000000
   19108                                                              10987654321098765432109876543210
   19109                                                              xxx01110xx1x0xx0111010xxxxxxxxxx
   19110                                                              fcmlt.  */
   19111                                                           return 198;
   19112                                                         }
   19113                                                       else
   19114                                                         {
   19115                                                           /* 33222222222211111111110000000000
   19116                                                              10987654321098765432109876543210
   19117                                                              xxx01110xx1x1xx0111010xxxxxxxxxx
   19118                                                              fcmlt.  */
   19119                                                           return 199;
   19120                                                         }
   19121                                                     }
   19122                                                   else
   19123                                                     {
   19124                                                       if (((word >> 29) & 0x1) == 0)
   19125                                                         {
   19126                                                           /* 33222222222211111111110000000000
   19127                                                              10987654321098765432109876543210
   19128                                                              xx001110xx1xxxx1111010xxxxxxxxxx
   19129                                                              frint32z.  */
   19130                                                           return 158;
   19131                                                         }
   19132                                                       else
   19133                                                         {
   19134                                                           /* 33222222222211111111110000000000
   19135                                                              10987654321098765432109876543210
   19136                                                              xx101110xx1xxxx1111010xxxxxxxxxx
   19137                                                              frint32x.  */
   19138                                                           return 159;
   19139                                                         }
   19140                                                     }
   19141                                                 }
   19142                                             }
   19143                                         }
   19144                                       else
   19145                                         {
   19146                                           if (((word >> 13) & 0x1) == 0)
   19147                                             {
   19148                                               if (((word >> 14) & 0x1) == 0)
   19149                                                 {
   19150                                                   if (((word >> 16) & 0x1) == 0)
   19151                                                     {
   19152                                                       if (((word >> 29) & 0x1) == 0)
   19153                                                         {
   19154                                                           /* 33222222222211111111110000000000
   19155                                                              10987654321098765432109876543210
   19156                                                              xx001110xx1xxxx0100110xxxxxxxxxx
   19157                                                              cmeq.  */
   19158                                                           return 171;
   19159                                                         }
   19160                                                       else
   19161                                                         {
   19162                                                           /* 33222222222211111111110000000000
   19163                                                              10987654321098765432109876543210
   19164                                                              xx101110xx1xxxx0100110xxxxxxxxxx
   19165                                                              cmle.  */
   19166                                                           return 220;
   19167                                                         }
   19168                                                     }
   19169                                                   else
   19170                                                     {
   19171                                                       if (((word >> 19) & 0x1) == 0)
   19172                                                         {
   19173                                                           if (((word >> 23) & 0x1) == 0)
   19174                                                             {
   19175                                                               if (((word >> 29) & 0x1) == 0)
   19176                                                                 {
   19177                                                                   /* 33222222222211111111110000000000
   19178                                                                      10987654321098765432109876543210
   19179                                                                      xx0011100x1x0xx1100110xxxxxxxxxx
   19180                                                                      frintm.  */
   19181                                                                   return 184;
   19182                                                                 }
   19183                                                               else
   19184                                                                 {
   19185                                                                   /* 33222222222211111111110000000000
   19186                                                                      10987654321098765432109876543210
   19187                                                                      xx1011100x1x0xx1100110xxxxxxxxxx
   19188                                                                      frintx.  */
   19189                                                                   return 232;
   19190                                                                 }
   19191                                                             }
   19192                                                           else
   19193                                                             {
   19194                                                               if (((word >> 29) & 0x1) == 0)
   19195                                                                 {
   19196                                                                   /* 33222222222211111111110000000000
   19197                                                                      10987654321098765432109876543210
   19198                                                                      xx0011101x1x0xx1100110xxxxxxxxxx
   19199                                                                      frintz.  */
   19200                                                                   return 204;
   19201                                                                 }
   19202                                                               else
   19203                                                                 {
   19204                                                                   /* 33222222222211111111110000000000
   19205                                                                      10987654321098765432109876543210
   19206                                                                      xx1011101x1x0xx1100110xxxxxxxxxx
   19207                                                                      frinti.  */
   19208                                                                   return 251;
   19209                                                                 }
   19210                                                             }
   19211                                                         }
   19212                                                       else
   19213                                                         {
   19214                                                           if (((word >> 23) & 0x1) == 0)
   19215                                                             {
   19216                                                               if (((word >> 29) & 0x1) == 0)
   19217                                                                 {
   19218                                                                   /* 33222222222211111111110000000000
   19219                                                                      10987654321098765432109876543210
   19220                                                                      xx0011100x1x1xx1100110xxxxxxxxxx
   19221                                                                      frintm.  */
   19222                                                                   return 185;
   19223                                                                 }
   19224                                                               else
   19225                                                                 {
   19226                                                                   /* 33222222222211111111110000000000
   19227                                                                      10987654321098765432109876543210
   19228                                                                      xx1011100x1x1xx1100110xxxxxxxxxx
   19229                                                                      frintx.  */
   19230                                                                   return 233;
   19231                                                                 }
   19232                                                             }
   19233                                                           else
   19234                                                             {
   19235                                                               if (((word >> 29) & 0x1) == 0)
   19236                                                                 {
   19237                                                                   /* 33222222222211111111110000000000
   19238                                                                      10987654321098765432109876543210
   19239                                                                      xx0011101x1x1xx1100110xxxxxxxxxx
   19240                                                                      frintz.  */
   19241                                                                   return 205;
   19242                                                                 }
   19243                                                               else
   19244                                                                 {
   19245                                                                   /* 33222222222211111111110000000000
   19246                                                                      10987654321098765432109876543210
   19247                                                                      xx1011101x1x1xx1100110xxxxxxxxxx
   19248                                                                      frinti.  */
   19249                                                                   return 252;
   19250                                                                 }
   19251                                                             }
   19252                                                         }
   19253                                                     }
   19254                                                 }
   19255                                               else
   19256                                                 {
   19257                                                   if (((word >> 16) & 0x1) == 0)
   19258                                                     {
   19259                                                       if (((word >> 19) & 0x1) == 0)
   19260                                                         {
   19261                                                           if (((word >> 29) & 0x1) == 0)
   19262                                                             {
   19263                                                               /* 33222222222211111111110000000000
   19264                                                                  10987654321098765432109876543210
   19265                                                                  xx001110xx1x0xx0110110xxxxxxxxxx
   19266                                                                  fcmeq.  */
   19267                                                               return 196;
   19268                                                             }
   19269                                                           else
   19270                                                             {
   19271                                                               /* 33222222222211111111110000000000
   19272                                                                  10987654321098765432109876543210
   19273                                                                  xx101110xx1x0xx0110110xxxxxxxxxx
   19274                                                                  fcmle.  */
   19275                                                               return 247;
   19276                                                             }
   19277                                                         }
   19278                                                       else
   19279                                                         {
   19280                                                           if (((word >> 29) & 0x1) == 0)
   19281                                                             {
   19282                                                               /* 33222222222211111111110000000000
   19283                                                                  10987654321098765432109876543210
   19284                                                                  xx001110xx1x1xx0110110xxxxxxxxxx
   19285                                                                  fcmeq.  */
   19286                                                               return 197;
   19287                                                             }
   19288                                                           else
   19289                                                             {
   19290                                                               /* 33222222222211111111110000000000
   19291                                                                  10987654321098765432109876543210
   19292                                                                  xx101110xx1x1xx0110110xxxxxxxxxx
   19293                                                                  fcmle.  */
   19294                                                               return 248;
   19295                                                             }
   19296                                                         }
   19297                                                     }
   19298                                                   else
   19299                                                     {
   19300                                                       if (((word >> 19) & 0x1) == 0)
   19301                                                         {
   19302                                                           if (((word >> 23) & 0x1) == 0)
   19303                                                             {
   19304                                                               if (((word >> 29) & 0x1) == 0)
   19305                                                                 {
   19306                                                                   /* 33222222222211111111110000000000
   19307                                                                      10987654321098765432109876543210
   19308                                                                      xx0011100x1x0xx1110110xxxxxxxxxx
   19309                                                                      scvtf.  */
   19310                                                                   return 192;
   19311                                                                 }
   19312                                                               else
   19313                                                                 {
   19314                                                                   /* 33222222222211111111110000000000
   19315                                                                      10987654321098765432109876543210
   19316                                                                      xx1011100x1x0xx1110110xxxxxxxxxx
   19317                                                                      ucvtf.  */
   19318                                                                   return 240;
   19319                                                                 }
   19320                                                             }
   19321                                                           else
   19322                                                             {
   19323                                                               if (((word >> 29) & 0x1) == 0)
   19324                                                                 {
   19325                                                                   /* 33222222222211111111110000000000
   19326                                                                      10987654321098765432109876543210
   19327                                                                      xx0011101x1x0xx1110110xxxxxxxxxx
   19328                                                                      frecpe.  */
   19329                                                                   return 211;
   19330                                                                 }
   19331                                                               else
   19332                                                                 {
   19333                                                                   /* 33222222222211111111110000000000
   19334                                                                      10987654321098765432109876543210
   19335                                                                      xx1011101x1x0xx1110110xxxxxxxxxx
   19336                                                                      frsqrte.  */
   19337                                                                   return 258;
   19338                                                                 }
   19339                                                             }
   19340                                                         }
   19341                                                       else
   19342                                                         {
   19343                                                           if (((word >> 23) & 0x1) == 0)
   19344                                                             {
   19345                                                               if (((word >> 29) & 0x1) == 0)
   19346                                                                 {
   19347                                                                   /* 33222222222211111111110000000000
   19348                                                                      10987654321098765432109876543210
   19349                                                                      xx0011100x1x1xx1110110xxxxxxxxxx
   19350                                                                      scvtf.  */
   19351                                                                   return 193;
   19352                                                                 }
   19353                                                               else
   19354                                                                 {
   19355                                                                   /* 33222222222211111111110000000000
   19356                                                                      10987654321098765432109876543210
   19357                                                                      xx1011100x1x1xx1110110xxxxxxxxxx
   19358                                                                      ucvtf.  */
   19359                                                                   return 241;
   19360                                                                 }
   19361                                                             }
   19362                                                           else
   19363                                                             {
   19364                                                               if (((word >> 29) & 0x1) == 0)
   19365                                                                 {
   19366                                                                   /* 33222222222211111111110000000000
   19367                                                                      10987654321098765432109876543210
   19368                                                                      xx0011101x1x1xx1110110xxxxxxxxxx
   19369                                                                      frecpe.  */
   19370                                                                   return 212;
   19371                                                                 }
   19372                                                               else
   19373                                                                 {
   19374                                                                   /* 33222222222211111111110000000000
   19375                                                                      10987654321098765432109876543210
   19376                                                                      xx1011101x1x1xx1110110xxxxxxxxxx
   19377                                                                      frsqrte.  */
   19378                                                                   return 259;
   19379                                                                 }
   19380                                                             }
   19381                                                         }
   19382                                                     }
   19383                                                 }
   19384                                             }
   19385                                           else
   19386                                             {
   19387                                               if (((word >> 14) & 0x1) == 0)
   19388                                                 {
   19389                                                   if (((word >> 16) & 0x1) == 0)
   19390                                                     {
   19391                                                       if (((word >> 29) & 0x1) == 0)
   19392                                                         {
   19393                                                           /* 33222222222211111111110000000000
   19394                                                              10987654321098765432109876543210
   19395                                                              xx001110xx1xxxx0101110xxxxxxxxxx
   19396                                                              abs.  */
   19397                                                           return 173;
   19398                                                         }
   19399                                                       else
   19400                                                         {
   19401                                                           /* 33222222222211111111110000000000
   19402                                                              10987654321098765432109876543210
   19403                                                              xx101110xx1xxxx0101110xxxxxxxxxx
   19404                                                              neg.  */
   19405                                                           return 221;
   19406                                                         }
   19407                                                     }
   19408                                                   else
   19409                                                     {
   19410                                                       if (((word >> 19) & 0x1) == 0)
   19411                                                         {
   19412                                                           if (((word >> 20) & 0x1) == 0)
   19413                                                             {
   19414                                                               if (((word >> 23) & 0x1) == 0)
   19415                                                                 {
   19416                                                                   if (((word >> 29) & 0x1) == 0)
   19417                                                                     {
   19418                                                                       /* 33222222222211111111110000000000
   19419                                                                          10987654321098765432109876543210
   19420                                                                          xx0011100x100xx1101110xxxxxxxxxx
   19421                                                                          fcvtms.  */
   19422                                                                       return 188;
   19423                                                                     }
   19424                                                                   else
   19425                                                                     {
   19426                                                                       /* 33222222222211111111110000000000
   19427                                                                          10987654321098765432109876543210
   19428                                                                          xx1011100x100xx1101110xxxxxxxxxx
   19429                                                                          fcvtmu.  */
   19430                                                                       return 236;
   19431                                                                     }
   19432                                                                 }
   19433                                                               else
   19434                                                                 {
   19435                                                                   if (((word >> 29) & 0x1) == 0)
   19436                                                                     {
   19437                                                                       /* 33222222222211111111110000000000
   19438                                                                          10987654321098765432109876543210
   19439                                                                          xx0011101x100xx1101110xxxxxxxxxx
   19440                                                                          fcvtzs.  */
   19441                                                                       return 208;
   19442                                                                     }
   19443                                                                   else
   19444                                                                     {
   19445                                                                       /* 33222222222211111111110000000000
   19446                                                                          10987654321098765432109876543210
   19447                                                                          xx1011101x100xx1101110xxxxxxxxxx
   19448                                                                          fcvtzu.  */
   19449                                                                       return 255;
   19450                                                                     }
   19451                                                                 }
   19452                                                             }
   19453                                                           else
   19454                                                             {
   19455                                                               /* 33222222222211111111110000000000
   19456                                                                  10987654321098765432109876543210
   19457                                                                  xxx01110xx110xx1101110xxxxxxxxxx
   19458                                                                  addv.  */
   19459                                                               return 32;
   19460                                                             }
   19461                                                         }
   19462                                                       else
   19463                                                         {
   19464                                                           if (((word >> 23) & 0x1) == 0)
   19465                                                             {
   19466                                                               if (((word >> 29) & 0x1) == 0)
   19467                                                                 {
   19468                                                                   /* 33222222222211111111110000000000
   19469                                                                      10987654321098765432109876543210
   19470                                                                      xx0011100x1x1xx1101110xxxxxxxxxx
   19471                                                                      fcvtms.  */
   19472                                                                   return 189;
   19473                                                                 }
   19474                                                               else
   19475                                                                 {
   19476                                                                   /* 33222222222211111111110000000000
   19477                                                                      10987654321098765432109876543210
   19478                                                                      xx1011100x1x1xx1101110xxxxxxxxxx
   19479                                                                      fcvtmu.  */
   19480                                                                   return 237;
   19481                                                                 }
   19482                                                             }
   19483                                                           else
   19484                                                             {
   19485                                                               if (((word >> 29) & 0x1) == 0)
   19486                                                                 {
   19487                                                                   /* 33222222222211111111110000000000
   19488                                                                      10987654321098765432109876543210
   19489                                                                      xx0011101x1x1xx1101110xxxxxxxxxx
   19490                                                                      fcvtzs.  */
   19491                                                                   return 209;
   19492                                                                 }
   19493                                                               else
   19494                                                                 {
   19495                                                                   /* 33222222222211111111110000000000
   19496                                                                      10987654321098765432109876543210
   19497                                                                      xx1011101x1x1xx1101110xxxxxxxxxx
   19498                                                                      fcvtzu.  */
   19499                                                                   return 256;
   19500                                                                 }
   19501                                                             }
   19502                                                         }
   19503                                                     }
   19504                                                 }
   19505                                               else
   19506                                                 {
   19507                                                   if (((word >> 16) & 0x1) == 0)
   19508                                                     {
   19509                                                       if (((word >> 19) & 0x1) == 0)
   19510                                                         {
   19511                                                           if (((word >> 20) & 0x1) == 0)
   19512                                                             {
   19513                                                               if (((word >> 29) & 0x1) == 0)
   19514                                                                 {
   19515                                                                   /* 33222222222211111111110000000000
   19516                                                                      10987654321098765432109876543210
   19517                                                                      xx001110xx100xx0111110xxxxxxxxxx
   19518                                                                      fabs.  */
   19519                                                                   return 200;
   19520                                                                 }
   19521                                                               else
   19522                                                                 {
   19523                                                                   /* 33222222222211111111110000000000
   19524                                                                      10987654321098765432109876543210
   19525                                                                      xx101110xx100xx0111110xxxxxxxxxx
   19526                                                                      fneg.  */
   19527                                                                   return 249;
   19528                                                                 }
   19529                                                             }
   19530                                                           else
   19531                                                             {
   19532                                                               if (((word >> 23) & 0x1) == 0)
   19533                                                                 {
   19534                                                                   if (((word >> 29) & 0x1) == 0)
   19535                                                                     {
   19536                                                                       /* 33222222222211111111110000000000
   19537                                                                          10987654321098765432109876543210
   19538                                                                          xx0011100x110xx0111110xxxxxxxxxx
   19539                                                                          fmaxv.  */
   19540                                                                       return 39;
   19541                                                                     }
   19542                                                                   else
   19543                                                                     {
   19544                                                                       /* 33222222222211111111110000000000
   19545                                                                          10987654321098765432109876543210
   19546                                                                          xx1011100x110xx0111110xxxxxxxxxx
   19547                                                                          fmaxv.  */
   19548                                                                       return 38;
   19549                                                                     }
   19550                                                                 }
   19551                                                               else
   19552                                                                 {
   19553                                                                   if (((word >> 29) & 0x1) == 0)
   19554                                                                     {
   19555                                                                       /* 33222222222211111111110000000000
   19556                                                                          10987654321098765432109876543210
   19557                                                                          xx0011101x110xx0111110xxxxxxxxxx
   19558                                                                          fminv.  */
   19559                                                                       return 43;
   19560                                                                     }
   19561                                                                   else
   19562                                                                     {
   19563                                                                       /* 33222222222211111111110000000000
   19564                                                                          10987654321098765432109876543210
   19565                                                                          xx1011101x110xx0111110xxxxxxxxxx
   19566                                                                          fminv.  */
   19567                                                                       return 42;
   19568                                                                     }
   19569                                                                 }
   19570                                                             }
   19571                                                         }
   19572                                                       else
   19573                                                         {
   19574                                                           if (((word >> 29) & 0x1) == 0)
   19575                                                             {
   19576                                                               /* 33222222222211111111110000000000
   19577                                                                  10987654321098765432109876543210
   19578                                                                  xx001110xx1x1xx0111110xxxxxxxxxx
   19579                                                                  fabs.  */
   19580                                                               return 201;
   19581                                                             }
   19582                                                           else
   19583                                                             {
   19584                                                               /* 33222222222211111111110000000000
   19585                                                                  10987654321098765432109876543210
   19586                                                                  xx101110xx1x1xx0111110xxxxxxxxxx
   19587                                                                  fneg.  */
   19588                                                               return 250;
   19589                                                             }
   19590                                                         }
   19591                                                     }
   19592                                                   else
   19593                                                     {
   19594                                                       if (((word >> 19) & 0x1) == 0)
   19595                                                         {
   19596                                                           if (((word >> 23) & 0x1) == 0)
   19597                                                             {
   19598                                                               if (((word >> 29) & 0x1) == 0)
   19599                                                                 {
   19600                                                                   /* 33222222222211111111110000000000
   19601                                                                      10987654321098765432109876543210
   19602                                                                      xx0011100x1x0xx1111110xxxxxxxxxx
   19603                                                                      frint64z.  */
   19604                                                                   return 160;
   19605                                                                 }
   19606                                                               else
   19607                                                                 {
   19608                                                                   /* 33222222222211111111110000000000
   19609                                                                      10987654321098765432109876543210
   19610                                                                      xx1011100x1x0xx1111110xxxxxxxxxx
   19611                                                                      frint64x.  */
   19612                                                                   return 161;
   19613                                                                 }
   19614                                                             }
   19615                                                           else
   19616                                                             {
   19617                                                               /* 33222222222211111111110000000000
   19618                                                                  10987654321098765432109876543210
   19619                                                                  xxx011101x1x0xx1111110xxxxxxxxxx
   19620                                                                  fsqrt.  */
   19621                                                               return 260;
   19622                                                             }
   19623                                                         }
   19624                                                       else
   19625                                                         {
   19626                                                           /* 33222222222211111111110000000000
   19627                                                              10987654321098765432109876543210
   19628                                                              xxx01110xx1x1xx1111110xxxxxxxxxx
   19629                                                              fsqrt.  */
   19630                                                           return 261;
   19631                                                         }
   19632                                                     }
   19633                                                 }
   19634                                             }
   19635                                         }
   19636                                     }
   19637                                 }
   19638                               else
   19639                                 {
   19640                                   if (((word >> 11) & 0x1) == 0)
   19641                                     {
   19642                                       if (((word >> 12) & 0x1) == 0)
   19643                                         {
   19644                                           if (((word >> 13) & 0x1) == 0)
   19645                                             {
   19646                                               if (((word >> 14) & 0x1) == 0)
   19647                                                 {
   19648                                                   if (((word >> 29) & 0x1) == 0)
   19649                                                     {
   19650                                                       if (((word >> 31) & 0x1) == 0)
   19651                                                         {
   19652                                                           /* 33222222222211111111110000000000
   19653                                                              10987654321098765432109876543210
   19654                                                              0x001110xx1xxxxx100001xxxxxxxxxx
   19655                                                              add.  */
   19656                                                           return 283;
   19657                                                         }
   19658                                                       else
   19659                                                         {
   19660                                                           /* 33222222222211111111110000000000
   19661                                                              10987654321098765432109876543210
   19662                                                              1x001110xx1xxxxx100001xxxxxxxxxx
   19663                                                              sha512h2.  */
   19664                                                           return 2346;
   19665                                                         }
   19666                                                     }
   19667                                                   else
   19668                                                     {
   19669                                                       /* 33222222222211111111110000000000
   19670                                                          10987654321098765432109876543210
   19671                                                          xx101110xx1xxxxx100001xxxxxxxxxx
   19672                                                          sub.  */
   19673                                                       return 335;
   19674                                                     }
   19675                                                 }
   19676                                               else
   19677                                                 {
   19678                                                   if (((word >> 23) & 0x1) == 0)
   19679                                                     {
   19680                                                       if (((word >> 29) & 0x1) == 0)
   19681                                                         {
   19682                                                           if (((word >> 31) & 0x1) == 0)
   19683                                                             {
   19684                                                               /* 33222222222211111111110000000000
   19685                                                                  10987654321098765432109876543210
   19686                                                                  0x0011100x1xxxxx110001xxxxxxxxxx
   19687                                                                  fmaxnm.  */
   19688                                                               return 291;
   19689                                                             }
   19690                                                           else
   19691                                                             {
   19692                                                               /* 33222222222211111111110000000000
   19693                                                                  10987654321098765432109876543210
   19694                                                                  1x0011100x1xxxxx110001xxxxxxxxxx
   19695                                                                  sm3partw2.  */
   19696                                                               return 2359;
   19697                                                             }
   19698                                                         }
   19699                                                       else
   19700                                                         {
   19701                                                           /* 33222222222211111111110000000000
   19702                                                              10987654321098765432109876543210
   19703                                                              xx1011100x1xxxxx110001xxxxxxxxxx
   19704                                                              fmaxnmp.  */
   19705                                                           return 342;
   19706                                                         }
   19707                                                     }
   19708                                                   else
   19709                                                     {
   19710                                                       if (((word >> 29) & 0x1) == 0)
   19711                                                         {
   19712                                                           /* 33222222222211111111110000000000
   19713                                                              10987654321098765432109876543210
   19714                                                              xx0011101x1xxxxx110001xxxxxxxxxx
   19715                                                              fminnm.  */
   19716                                                           return 307;
   19717                                                         }
   19718                                                       else
   19719                                                         {
   19720                                                           /* 33222222222211111111110000000000
   19721                                                              10987654321098765432109876543210
   19722                                                              xx1011101x1xxxxx110001xxxxxxxxxx
   19723                                                              fminnmp.  */
   19724                                                           return 358;
   19725                                                         }
   19726                                                     }
   19727                                                 }
   19728                                             }
   19729                                           else
   19730                                             {
   19731                                               if (((word >> 14) & 0x1) == 0)
   19732                                                 {
   19733                                                   if (((word >> 29) & 0x1) == 0)
   19734                                                     {
   19735                                                       /* 33222222222211111111110000000000
   19736                                                          10987654321098765432109876543210
   19737                                                          xx001110xx1xxxxx101001xxxxxxxxxx
   19738                                                          smaxp.  */
   19739                                                       return 287;
   19740                                                     }
   19741                                                   else
   19742                                                     {
   19743                                                       /* 33222222222211111111110000000000
   19744                                                          10987654321098765432109876543210
   19745                                                          xx101110xx1xxxxx101001xxxxxxxxxx
   19746                                                          umaxp.  */
   19747                                                       return 339;
   19748                                                     }
   19749                                                 }
   19750                                               else
   19751                                                 {
   19752                                                   if (((word >> 23) & 0x1) == 0)
   19753                                                     {
   19754                                                       if (((word >> 29) & 0x1) == 0)
   19755                                                         {
   19756                                                           /* 33222222222211111111110000000000
   19757                                                              10987654321098765432109876543210
   19758                                                              xx0011100x1xxxxx111001xxxxxxxxxx
   19759                                                              fcmeq.  */
   19760                                                           return 299;
   19761                                                         }
   19762                                                       else
   19763                                                         {
   19764                                                           /* 33222222222211111111110000000000
   19765                                                              10987654321098765432109876543210
   19766                                                              xx1011100x1xxxxx111001xxxxxxxxxx
   19767                                                              fcmge.  */
   19768                                                           return 348;
   19769                                                         }
   19770                                                     }
   19771                                                   else
   19772                                                     {
   19773                                                       /* 33222222222211111111110000000000
   19774                                                          10987654321098765432109876543210
   19775                                                          xxx011101x1xxxxx111001xxxxxxxxxx
   19776                                                          fcmgt.  */
   19777                                                       return 362;
   19778                                                     }
   19779                                                 }
   19780                                             }
   19781                                         }
   19782                                       else
   19783                                         {
   19784                                           if (((word >> 13) & 0x1) == 0)
   19785                                             {
   19786                                               if (((word >> 14) & 0x1) == 0)
   19787                                                 {
   19788                                                   if (((word >> 29) & 0x1) == 0)
   19789                                                     {
   19790                                                       /* 33222222222211111111110000000000
   19791                                                          10987654321098765432109876543210
   19792                                                          xx001110xx1xxxxx100101xxxxxxxxxx
   19793                                                          mla.  */
   19794                                                       return 285;
   19795                                                     }
   19796                                                   else
   19797                                                     {
   19798                                                       /* 33222222222211111111110000000000
   19799                                                          10987654321098765432109876543210
   19800                                                          xx101110xx1xxxxx100101xxxxxxxxxx
   19801                                                          mls.  */
   19802                                                       return 337;
   19803                                                     }
   19804                                                 }
   19805                                               else
   19806                                                 {
   19807                                                   if (((word >> 23) & 0x1) == 0)
   19808                                                     {
   19809                                                       if (((word >> 29) & 0x1) == 0)
   19810                                                         {
   19811                                                           /* 33222222222211111111110000000000
   19812                                                              10987654321098765432109876543210
   19813                                                              xx0011100x1xxxxx110101xxxxxxxxxx
   19814                                                              fadd.  */
   19815                                                           return 295;
   19816                                                         }
   19817                                                       else
   19818                                                         {
   19819                                                           /* 33222222222211111111110000000000
   19820                                                              10987654321098765432109876543210
   19821                                                              xx1011100x1xxxxx110101xxxxxxxxxx
   19822                                                              faddp.  */
   19823                                                           return 344;
   19824                                                         }
   19825                                                     }
   19826                                                   else
   19827                                                     {
   19828                                                       if (((word >> 29) & 0x1) == 0)
   19829                                                         {
   19830                                                           /* 33222222222211111111110000000000
   19831                                                              10987654321098765432109876543210
   19832                                                              xx0011101x1xxxxx110101xxxxxxxxxx
   19833                                                              fsub.  */
   19834                                                           return 311;
   19835                                                         }
   19836                                                       else
   19837                                                         {
   19838                                                           /* 33222222222211111111110000000000
   19839                                                              10987654321098765432109876543210
   19840                                                              xx1011101x1xxxxx110101xxxxxxxxxx
   19841                                                              fabd.  */
   19842                                                           return 360;
   19843                                                         }
   19844                                                     }
   19845                                                 }
   19846                                             }
   19847                                           else
   19848                                             {
   19849                                               if (((word >> 14) & 0x1) == 0)
   19850                                                 {
   19851                                                   if (((word >> 29) & 0x1) == 0)
   19852                                                     {
   19853                                                       /* 33222222222211111111110000000000
   19854                                                          10987654321098765432109876543210
   19855                                                          xx001110xx1xxxxx101101xxxxxxxxxx
   19856                                                          sqdmulh.  */
   19857                                                       return 289;
   19858                                                     }
   19859                                                   else
   19860                                                     {
   19861                                                       /* 33222222222211111111110000000000
   19862                                                          10987654321098765432109876543210
   19863                                                          xx101110xx1xxxxx101101xxxxxxxxxx
   19864                                                          sqrdmulh.  */
   19865                                                       return 341;
   19866                                                     }
   19867                                                 }
   19868                                               else
   19869                                                 {
   19870                                                   if (((word >> 23) & 0x1) == 0)
   19871                                                     {
   19872                                                       if (((word >> 29) & 0x1) == 0)
   19873                                                         {
   19874                                                           /* 33222222222211111111110000000000
   19875                                                              10987654321098765432109876543210
   19876                                                              xx0011100x1xxxxx111101xxxxxxxxxx
   19877                                                              fmax.  */
   19878                                                           return 301;
   19879                                                         }
   19880                                                       else
   19881                                                         {
   19882                                                           /* 33222222222211111111110000000000
   19883                                                              10987654321098765432109876543210
   19884                                                              xx1011100x1xxxxx111101xxxxxxxxxx
   19885                                                              fmaxp.  */
   19886                                                           return 352;
   19887                                                         }
   19888                                                     }
   19889                                                   else
   19890                                                     {
   19891                                                       if (((word >> 29) & 0x1) == 0)
   19892                                                         {
   19893                                                           /* 33222222222211111111110000000000
   19894                                                              10987654321098765432109876543210
   19895                                                              xx0011101x1xxxxx111101xxxxxxxxxx
   19896                                                              fmin.  */
   19897                                                           return 313;
   19898                                                         }
   19899                                                       else
   19900                                                         {
   19901                                                           /* 33222222222211111111110000000000
   19902                                                              10987654321098765432109876543210
   19903                                                              xx1011101x1xxxxx111101xxxxxxxxxx
   19904                                                              fminp.  */
   19905                                                           return 366;
   19906                                                         }
   19907                                                     }
   19908                                                 }
   19909                                             }
   19910                                         }
   19911                                     }
   19912                                   else
   19913                                     {
   19914                                       if (((word >> 12) & 0x1) == 0)
   19915                                         {
   19916                                           if (((word >> 13) & 0x1) == 0)
   19917                                             {
   19918                                               if (((word >> 14) & 0x1) == 0)
   19919                                                 {
   19920                                                   if (((word >> 29) & 0x1) == 0)
   19921                                                     {
   19922                                                       if (((word >> 31) & 0x1) == 0)
   19923                                                         {
   19924                                                           /* 33222222222211111111110000000000
   19925                                                              10987654321098765432109876543210
   19926                                                              0x001110xx1xxxxx100011xxxxxxxxxx
   19927                                                              cmtst.  */
   19928                                                           return 284;
   19929                                                         }
   19930                                                       else
   19931                                                         {
   19932                                                           /* 33222222222211111111110000000000
   19933                                                              10987654321098765432109876543210
   19934                                                              1x001110xx1xxxxx100011xxxxxxxxxx
   19935                                                              rax1.  */
   19936                                                           return 2350;
   19937                                                         }
   19938                                                     }
   19939                                                   else
   19940                                                     {
   19941                                                       /* 33222222222211111111110000000000
   19942                                                          10987654321098765432109876543210
   19943                                                          xx101110xx1xxxxx100011xxxxxxxxxx
   19944                                                          cmeq.  */
   19945                                                       return 336;
   19946                                                     }
   19947                                                 }
   19948                                               else
   19949                                                 {
   19950                                                   if (((word >> 23) & 0x1) == 0)
   19951                                                     {
   19952                                                       if (((word >> 29) & 0x1) == 0)
   19953                                                         {
   19954                                                           /* 33222222222211111111110000000000
   19955                                                              10987654321098765432109876543210
   19956                                                              xx0011100x1xxxxx110011xxxxxxxxxx
   19957                                                              fmla.  */
   19958                                                           return 293;
   19959                                                         }
   19960                                                       else
   19961                                                         {
   19962                                                           if (((word >> 30) & 0x1) == 0)
   19963                                                             {
   19964                                                               /* 33222222222211111111110000000000
   19965                                                                  10987654321098765432109876543210
   19966                                                                  x01011100x1xxxxx110011xxxxxxxxxx
   19967                                                                  fmlal2.  */
   19968                                                               return 2364;
   19969                                                             }
   19970                                                           else
   19971                                                             {
   19972                                                               /* 33222222222211111111110000000000
   19973                                                                  10987654321098765432109876543210
   19974                                                                  x11011100x1xxxxx110011xxxxxxxxxx
   19975                                                                  fmlal2.  */
   19976                                                               return 2368;
   19977                                                             }
   19978                                                         }
   19979                                                     }
   19980                                                   else
   19981                                                     {
   19982                                                       if (((word >> 29) & 0x1) == 0)
   19983                                                         {
   19984                                                           /* 33222222222211111111110000000000
   19985                                                              10987654321098765432109876543210
   19986                                                              xx0011101x1xxxxx110011xxxxxxxxxx
   19987                                                              fmls.  */
   19988                                                           return 309;
   19989                                                         }
   19990                                                       else
   19991                                                         {
   19992                                                           if (((word >> 30) & 0x1) == 0)
   19993                                                             {
   19994                                                               /* 33222222222211111111110000000000
   19995                                                                  10987654321098765432109876543210
   19996                                                                  x01011101x1xxxxx110011xxxxxxxxxx
   19997                                                                  fmlsl2.  */
   19998                                                               return 2365;
   19999                                                             }
   20000                                                           else
   20001                                                             {
   20002                                                               /* 33222222222211111111110000000000
   20003                                                                  10987654321098765432109876543210
   20004                                                                  x11011101x1xxxxx110011xxxxxxxxxx
   20005                                                                  fmlsl2.  */
   20006                                                               return 2369;
   20007                                                             }
   20008                                                         }
   20009                                                     }
   20010                                                 }
   20011                                             }
   20012                                           else
   20013                                             {
   20014                                               if (((word >> 14) & 0x1) == 0)
   20015                                                 {
   20016                                                   if (((word >> 29) & 0x1) == 0)
   20017                                                     {
   20018                                                       /* 33222222222211111111110000000000
   20019                                                          10987654321098765432109876543210
   20020                                                          xx001110xx1xxxxx101011xxxxxxxxxx
   20021                                                          sminp.  */
   20022                                                       return 288;
   20023                                                     }
   20024                                                   else
   20025                                                     {
   20026                                                       /* 33222222222211111111110000000000
   20027                                                          10987654321098765432109876543210
   20028                                                          xx101110xx1xxxxx101011xxxxxxxxxx
   20029                                                          uminp.  */
   20030                                                       return 340;
   20031                                                     }
   20032                                                 }
   20033                                               else
   20034                                                 {
   20035                                                   if (((word >> 23) & 0x1) == 0)
   20036                                                     {
   20037                                                       if (((word >> 29) & 0x1) == 0)
   20038                                                         {
   20039                                                           if (((word >> 30) & 0x1) == 0)
   20040                                                             {
   20041                                                               /* 33222222222211111111110000000000
   20042                                                                  10987654321098765432109876543210
   20043                                                                  x00011100x1xxxxx111011xxxxxxxxxx
   20044                                                                  fmlal.  */
   20045                                                               return 2362;
   20046                                                             }
   20047                                                           else
   20048                                                             {
   20049                                                               /* 33222222222211111111110000000000
   20050                                                                  10987654321098765432109876543210
   20051                                                                  x10011100x1xxxxx111011xxxxxxxxxx
   20052                                                                  fmlal.  */
   20053                                                               return 2366;
   20054                                                             }
   20055                                                         }
   20056                                                       else
   20057                                                         {
   20058                                                           /* 33222222222211111111110000000000
   20059                                                              10987654321098765432109876543210
   20060                                                              xx1011100x1xxxxx111011xxxxxxxxxx
   20061                                                              facge.  */
   20062                                                           return 350;
   20063                                                         }
   20064                                                     }
   20065                                                   else
   20066                                                     {
   20067                                                       if (((word >> 29) & 0x1) == 0)
   20068                                                         {
   20069                                                           if (((word >> 30) & 0x1) == 0)
   20070                                                             {
   20071                                                               /* 33222222222211111111110000000000
   20072                                                                  10987654321098765432109876543210
   20073                                                                  x00011101x1xxxxx111011xxxxxxxxxx
   20074                                                                  fmlsl.  */
   20075                                                               return 2363;
   20076                                                             }
   20077                                                           else
   20078                                                             {
   20079                                                               /* 33222222222211111111110000000000
   20080                                                                  10987654321098765432109876543210
   20081                                                                  x10011101x1xxxxx111011xxxxxxxxxx
   20082                                                                  fmlsl.  */
   20083                                                               return 2367;
   20084                                                             }
   20085                                                         }
   20086                                                       else
   20087                                                         {
   20088                                                           /* 33222222222211111111110000000000
   20089                                                              10987654321098765432109876543210
   20090                                                              xx1011101x1xxxxx111011xxxxxxxxxx
   20091                                                              facgt.  */
   20092                                                           return 364;
   20093                                                         }
   20094                                                     }
   20095                                                 }
   20096                                             }
   20097                                         }
   20098                                       else
   20099                                         {
   20100                                           if (((word >> 13) & 0x1) == 0)
   20101                                             {
   20102                                               if (((word >> 14) & 0x1) == 0)
   20103                                                 {
   20104                                                   if (((word >> 29) & 0x1) == 0)
   20105                                                     {
   20106                                                       /* 33222222222211111111110000000000
   20107                                                          10987654321098765432109876543210
   20108                                                          xx001110xx1xxxxx100111xxxxxxxxxx
   20109                                                          mul.  */
   20110                                                       return 286;
   20111                                                     }
   20112                                                   else
   20113                                                     {
   20114                                                       /* 33222222222211111111110000000000
   20115                                                          10987654321098765432109876543210
   20116                                                          xx101110xx1xxxxx100111xxxxxxxxxx
   20117                                                          pmul.  */
   20118                                                       return 338;
   20119                                                     }
   20120                                                 }
   20121                                               else
   20122                                                 {
   20123                                                   if (((word >> 29) & 0x1) == 0)
   20124                                                     {
   20125                                                       /* 33222222222211111111110000000000
   20126                                                          10987654321098765432109876543210
   20127                                                          xx001110xx1xxxxx110111xxxxxxxxxx
   20128                                                          fmulx.  */
   20129                                                       return 297;
   20130                                                     }
   20131                                                   else
   20132                                                     {
   20133                                                       /* 33222222222211111111110000000000
   20134                                                          10987654321098765432109876543210
   20135                                                          xx101110xx1xxxxx110111xxxxxxxxxx
   20136                                                          fmul.  */
   20137                                                       return 346;
   20138                                                     }
   20139                                                 }
   20140                                             }
   20141                                           else
   20142                                             {
   20143                                               if (((word >> 14) & 0x1) == 0)
   20144                                                 {
   20145                                                   /* 33222222222211111111110000000000
   20146                                                      10987654321098765432109876543210
   20147                                                      xxx01110xx1xxxxx101111xxxxxxxxxx
   20148                                                      addp.  */
   20149                                                   return 290;
   20150                                                 }
   20151                                               else
   20152                                                 {
   20153                                                   if (((word >> 23) & 0x1) == 0)
   20154                                                     {
   20155                                                       if (((word >> 29) & 0x1) == 0)
   20156                                                         {
   20157                                                           /* 33222222222211111111110000000000
   20158                                                              10987654321098765432109876543210
   20159                                                              xx0011100x1xxxxx111111xxxxxxxxxx
   20160                                                              frecps.  */
   20161                                                           return 303;
   20162                                                         }
   20163                                                       else
   20164                                                         {
   20165                                                           /* 33222222222211111111110000000000
   20166                                                              10987654321098765432109876543210
   20167                                                              xx1011100x1xxxxx111111xxxxxxxxxx
   20168                                                              fdiv.  */
   20169                                                           return 354;
   20170                                                         }
   20171                                                     }
   20172                                                   else
   20173                                                     {
   20174                                                       /* 33222222222211111111110000000000
   20175                                                          10987654321098765432109876543210
   20176                                                          xxx011101x1xxxxx111111xxxxxxxxxx
   20177                                                          frsqrts.  */
   20178                                                       return 315;
   20179                                                     }
   20180                                                 }
   20181                                             }
   20182                                         }
   20183                                     }
   20184                                 }
   20185                             }
   20186                         }
   20187                       else
   20188                         {
   20189                           if (((word >> 10) & 0x1) == 0)
   20190                             {
   20191                               if (((word >> 11) & 0x1) == 0)
   20192                                 {
   20193                                   if (((word >> 12) & 0x1) == 0)
   20194                                     {
   20195                                       if (((word >> 13) & 0x1) == 0)
   20196                                         {
   20197                                           if (((word >> 14) & 0x1) == 0)
   20198                                             {
   20199                                               if (((word >> 16) & 0x1) == 0)
   20200                                                 {
   20201                                                   if (((word >> 17) & 0x1) == 0)
   20202                                                     {
   20203                                                       if (((word >> 18) & 0x1) == 0)
   20204                                                         {
   20205                                                           if (((word >> 19) & 0x1) == 0)
   20206                                                             {
   20207                                                               if (((word >> 20) & 0x1) == 0)
   20208                                                                 {
   20209                                                                   /* 33222222222211111111110000000000
   20210                                                                      10987654321098765432109876543210
   20211                                                                      xxx11110xx100000x00000xxxxxxxxxx
   20212                                                                      fcvtns.  */
   20213                                                                   return 768;
   20214                                                                 }
   20215                                                               else
   20216                                                                 {
   20217                                                                   /* 33222222222211111111110000000000
   20218                                                                      10987654321098765432109876543210
   20219                                                                      xxx11110xx110000x00000xxxxxxxxxx
   20220                                                                      fcvtms.  */
   20221                                                                   return 788;
   20222                                                                 }
   20223                                                             }
   20224                                                           else
   20225                                                             {
   20226                                                               if (((word >> 20) & 0x1) == 0)
   20227                                                                 {
   20228                                                                   /* 33222222222211111111110000000000
   20229                                                                      10987654321098765432109876543210
   20230                                                                      xxx11110xx101000x00000xxxxxxxxxx
   20231                                                                      fcvtps.  */
   20232                                                                   return 784;
   20233                                                                 }
   20234                                                               else
   20235                                                                 {
   20236                                                                   /* 33222222222211111111110000000000
   20237                                                                      10987654321098765432109876543210
   20238                                                                      xxx11110xx111000x00000xxxxxxxxxx
   20239                                                                      fcvtzs.  */
   20240                                                                   return 792;
   20241                                                                 }
   20242                                                             }
   20243                                                         }
   20244                                                       else
   20245                                                         {
   20246                                                           /* 33222222222211111111110000000000
   20247                                                              10987654321098765432109876543210
   20248                                                              xxx11110xx1xx100x00000xxxxxxxxxx
   20249                                                              fcvtas.  */
   20250                                                           return 776;
   20251                                                         }
   20252                                                     }
   20253                                                   else
   20254                                                     {
   20255                                                       if (((word >> 18) & 0x1) == 0)
   20256                                                         {
   20257                                                           /* 33222222222211111111110000000000
   20258                                                              10987654321098765432109876543210
   20259                                                              xxx11110xx1xx010x00000xxxxxxxxxx
   20260                                                              scvtf.  */
   20261                                                           return 772;
   20262                                                         }
   20263                                                       else
   20264                                                         {
   20265                                                           if (((word >> 19) & 0x1) == 0)
   20266                                                             {
   20267                                                               /* 33222222222211111111110000000000
   20268                                                                  10987654321098765432109876543210
   20269                                                                  xxx11110xx1x0110x00000xxxxxxxxxx
   20270                                                                  fmov.  */
   20271                                                               return 780;
   20272                                                             }
   20273                                                           else
   20274                                                             {
   20275                                                               if (((word >> 20) & 0x1) == 0)
   20276                                                                 {
   20277                                                                   /* 33222222222211111111110000000000
   20278                                                                      10987654321098765432109876543210
   20279                                                                      xxx11110xx101110x00000xxxxxxxxxx
   20280                                                                      fmov.  */
   20281                                                                   return 796;
   20282                                                                 }
   20283                                                               else
   20284                                                                 {
   20285                                                                   /* 33222222222211111111110000000000
   20286                                                                      10987654321098765432109876543210
   20287                                                                      xxx11110xx111110x00000xxxxxxxxxx
   20288                                                                      fjcvtzs.  */
   20289                                                                   return 798;
   20290                                                                 }
   20291                                                             }
   20292                                                         }
   20293                                                     }
   20294                                                 }
   20295                                               else
   20296                                                 {
   20297                                                   if (((word >> 17) & 0x1) == 0)
   20298                                                     {
   20299                                                       if (((word >> 18) & 0x1) == 0)
   20300                                                         {
   20301                                                           if (((word >> 19) & 0x1) == 0)
   20302                                                             {
   20303                                                               if (((word >> 20) & 0x1) == 0)
   20304                                                                 {
   20305                                                                   /* 33222222222211111111110000000000
   20306                                                                      10987654321098765432109876543210
   20307                                                                      xxx11110xx100001x00000xxxxxxxxxx
   20308                                                                      fcvtnu.  */
   20309                                                                   return 770;
   20310                                                                 }
   20311                                                               else
   20312                                                                 {
   20313                                                                   /* 33222222222211111111110000000000
   20314                                                                      10987654321098765432109876543210
   20315                                                                      xxx11110xx110001x00000xxxxxxxxxx
   20316                                                                      fcvtmu.  */
   20317                                                                   return 790;
   20318                                                                 }
   20319                                                             }
   20320                                                           else
   20321                                                             {
   20322                                                               if (((word >> 20) & 0x1) == 0)
   20323                                                                 {
   20324                                                                   /* 33222222222211111111110000000000
   20325                                                                      10987654321098765432109876543210
   20326                                                                      xxx11110xx101001x00000xxxxxxxxxx
   20327                                                                      fcvtpu.  */
   20328                                                                   return 786;
   20329                                                                 }
   20330                                                               else
   20331                                                                 {
   20332                                                                   /* 33222222222211111111110000000000
   20333                                                                      10987654321098765432109876543210
   20334                                                                      xxx11110xx111001x00000xxxxxxxxxx
   20335                                                                      fcvtzu.  */
   20336                                                                   return 794;
   20337                                                                 }
   20338                                                             }
   20339                                                         }
   20340                                                       else
   20341                                                         {
   20342                                                           /* 33222222222211111111110000000000
   20343                                                              10987654321098765432109876543210
   20344                                                              xxx11110xx1xx101x00000xxxxxxxxxx
   20345                                                              fcvtau.  */
   20346                                                           return 778;
   20347                                                         }
   20348                                                     }
   20349                                                   else
   20350                                                     {
   20351                                                       if (((word >> 18) & 0x1) == 0)
   20352                                                         {
   20353                                                           /* 33222222222211111111110000000000
   20354                                                              10987654321098765432109876543210
   20355                                                              xxx11110xx1xx011x00000xxxxxxxxxx
   20356                                                              ucvtf.  */
   20357                                                           return 774;
   20358                                                         }
   20359                                                       else
   20360                                                         {
   20361                                                           if (((word >> 19) & 0x1) == 0)
   20362                                                             {
   20363                                                               /* 33222222222211111111110000000000
   20364                                                                  10987654321098765432109876543210
   20365                                                                  xxx11110xx1x0111x00000xxxxxxxxxx
   20366                                                                  fmov.  */
   20367                                                               return 782;
   20368                                                             }
   20369                                                           else
   20370                                                             {
   20371                                                               /* 33222222222211111111110000000000
   20372                                                                  10987654321098765432109876543210
   20373                                                                  xxx11110xx1x1111x00000xxxxxxxxxx
   20374                                                                  fmov.  */
   20375                                                               return 797;
   20376                                                             }
   20377                                                         }
   20378                                                     }
   20379                                                 }
   20380                                             }
   20381                                           else
   20382                                             {
   20383                                               if (((word >> 17) & 0x1) == 0)
   20384                                                 {
   20385                                                   if (((word >> 15) & 0x1) == 0)
   20386                                                     {
   20387                                                       if (((word >> 16) & 0x1) == 0)
   20388                                                         {
   20389                                                           if (((word >> 18) & 0x1) == 0)
   20390                                                             {
   20391                                                               if (((word >> 19) & 0x1) == 0)
   20392                                                                 {
   20393                                                                   /* 33222222222211111111110000000000
   20394                                                                      10987654321098765432109876543210
   20395                                                                      xxx11110xx1x0000010000xxxxxxxxxx
   20396                                                                      fmov.  */
   20397                                                                   return 817;
   20398                                                                 }
   20399                                                               else
   20400                                                                 {
   20401                                                                   /* 33222222222211111111110000000000
   20402                                                                      10987654321098765432109876543210
   20403                                                                      xxx11110xx1x1000010000xxxxxxxxxx
   20404                                                                      frint32z.  */
   20405                                                                   return 813;
   20406                                                                 }
   20407                                                             }
   20408                                                           else
   20409                                                             {
   20410                                                               /* 33222222222211111111110000000000
   20411                                                                  10987654321098765432109876543210
   20412                                                                  xxx11110xx1xx100010000xxxxxxxxxx
   20413                                                                  frintn.  */
   20414                                                               return 826;
   20415                                                             }
   20416                                                         }
   20417                                                       else
   20418                                                         {
   20419                                                           if (((word >> 18) & 0x1) == 0)
   20420                                                             {
   20421                                                               if (((word >> 19) & 0x1) == 0)
   20422                                                                 {
   20423                                                                   /* 33222222222211111111110000000000
   20424                                                                      10987654321098765432109876543210
   20425                                                                      xxx11110xx1x0001010000xxxxxxxxxx
   20426                                                                      fneg.  */
   20427                                                                   return 821;
   20428                                                                 }
   20429                                                               else
   20430                                                                 {
   20431                                                                   /* 33222222222211111111110000000000
   20432                                                                      10987654321098765432109876543210
   20433                                                                      xxx11110xx1x1001010000xxxxxxxxxx
   20434                                                                      frint64z.  */
   20435                                                                   return 815;
   20436                                                                 }
   20437                                                             }
   20438                                                           else
   20439                                                             {
   20440                                                               /* 33222222222211111111110000000000
   20441                                                                  10987654321098765432109876543210
   20442                                                                  xxx11110xx1xx101010000xxxxxxxxxx
   20443                                                                  frintm.  */
   20444                                                               return 830;
   20445                                                             }
   20446                                                         }
   20447                                                     }
   20448                                                   else
   20449                                                     {
   20450                                                       if (((word >> 16) & 0x1) == 0)
   20451                                                         {
   20452                                                           if (((word >> 18) & 0x1) == 0)
   20453                                                             {
   20454                                                               if (((word >> 19) & 0x1) == 0)
   20455                                                                 {
   20456                                                                   /* 33222222222211111111110000000000
   20457                                                                      10987654321098765432109876543210
   20458                                                                      xxx11110xx1x0000110000xxxxxxxxxx
   20459                                                                      fabs.  */
   20460                                                                   return 819;
   20461                                                                 }
   20462                                                               else
   20463                                                                 {
   20464                                                                   /* 33222222222211111111110000000000
   20465                                                                      10987654321098765432109876543210
   20466                                                                      xxx11110xx1x1000110000xxxxxxxxxx
   20467                                                                      frint32x.  */
   20468                                                                   return 814;
   20469                                                                 }
   20470                                                             }
   20471                                                           else
   20472                                                             {
   20473                                                               /* 33222222222211111111110000000000
   20474                                                                  10987654321098765432109876543210
   20475                                                                  xxx11110xx1xx100110000xxxxxxxxxx
   20476                                                                  frintp.  */
   20477                                                               return 828;
   20478                                                             }
   20479                                                         }
   20480                                                       else
   20481                                                         {
   20482                                                           if (((word >> 18) & 0x1) == 0)
   20483                                                             {
   20484                                                               if (((word >> 19) & 0x1) == 0)
   20485                                                                 {
   20486                                                                   /* 33222222222211111111110000000000
   20487                                                                      10987654321098765432109876543210
   20488                                                                      xxx11110xx1x0001110000xxxxxxxxxx
   20489                                                                      fsqrt.  */
   20490                                                                   return 823;
   20491                                                                 }
   20492                                                               else
   20493                                                                 {
   20494                                                                   /* 33222222222211111111110000000000
   20495                                                                      10987654321098765432109876543210
   20496                                                                      xxx11110xx1x1001110000xxxxxxxxxx
   20497                                                                      frint64x.  */
   20498                                                                   return 816;
   20499                                                                 }
   20500                                                             }
   20501                                                           else
   20502                                                             {
   20503                                                               /* 33222222222211111111110000000000
   20504                                                                  10987654321098765432109876543210
   20505                                                                  xxx11110xx1xx101110000xxxxxxxxxx
   20506                                                                  frintz.  */
   20507                                                               return 832;
   20508                                                             }
   20509                                                         }
   20510                                                     }
   20511                                                 }
   20512                                               else
   20513                                                 {
   20514                                                   if (((word >> 18) & 0x1) == 0)
   20515                                                     {
   20516                                                       /* 33222222222211111111110000000000
   20517                                                          10987654321098765432109876543210
   20518                                                          xxx11110xx1xx01xx10000xxxxxxxxxx
   20519                                                          fcvt.  */
   20520                                                       return 825;
   20521                                                     }
   20522                                                   else
   20523                                                     {
   20524                                                       if (((word >> 15) & 0x1) == 0)
   20525                                                         {
   20526                                                           if (((word >> 16) & 0x1) == 0)
   20527                                                             {
   20528                                                               /* 33222222222211111111110000000000
   20529                                                                  10987654321098765432109876543210
   20530                                                                  xxx11110xx1xx110010000xxxxxxxxxx
   20531                                                                  frinta.  */
   20532                                                               return 834;
   20533                                                             }
   20534                                                           else
   20535                                                             {
   20536                                                               /* 33222222222211111111110000000000
   20537                                                                  10987654321098765432109876543210
   20538                                                                  xxx11110xx1xx111010000xxxxxxxxxx
   20539                                                                  frintx.  */
   20540                                                               return 836;
   20541                                                             }
   20542                                                         }
   20543                                                       else
   20544                                                         {
   20545                                                           /* 33222222222211111111110000000000
   20546                                                              10987654321098765432109876543210
   20547                                                              xxx11110xx1xx11x110000xxxxxxxxxx
   20548                                                              frinti.  */
   20549                                                           return 838;
   20550                                                         }
   20551                                                     }
   20552                                                 }
   20553                                             }
   20554                                         }
   20555                                       else
   20556                                         {
   20557                                           if (((word >> 3) & 0x1) == 0)
   20558                                             {
   20559                                               if (((word >> 4) & 0x1) == 0)
   20560                                                 {
   20561                                                   /* 33222222222211111111110000000000
   20562                                                      10987654321098765432109876543210
   20563                                                      xxx11110xx1xxxxxxx1000xxxxx00xxx
   20564                                                      fcmp.  */
   20565                                                   return 803;
   20566                                                 }
   20567                                               else
   20568                                                 {
   20569                                                   /* 33222222222211111111110000000000
   20570                                                      10987654321098765432109876543210
   20571                                                      xxx11110xx1xxxxxxx1000xxxxx10xxx
   20572                                                      fcmpe.  */
   20573                                                   return 805;
   20574                                                 }
   20575                                             }
   20576                                           else
   20577                                             {
   20578                                               if (((word >> 4) & 0x1) == 0)
   20579                                                 {
   20580                                                   /* 33222222222211111111110000000000
   20581                                                      10987654321098765432109876543210
   20582                                                      xxx11110xx1xxxxxxx1000xxxxx01xxx
   20583                                                      fcmp.  */
   20584                                                   return 807;
   20585                                                 }
   20586                                               else
   20587                                                 {
   20588                                                   /* 33222222222211111111110000000000
   20589                                                      10987654321098765432109876543210
   20590                                                      xxx11110xx1xxxxxxx1000xxxxx11xxx
   20591                                                      fcmpe.  */
   20592                                                   return 809;
   20593                                                 }
   20594                                             }
   20595                                         }
   20596                                     }
   20597                                   else
   20598                                     {
   20599                                       if (((word >> 30) & 0x1) == 0)
   20600                                         {
   20601                                           /* 33222222222211111111110000000000
   20602                                              10987654321098765432109876543210
   20603                                              x0x11110xx1xxxxxxxx100xxxxxxxxxx
   20604                                              fmov.  */
   20605                                           return 866;
   20606                                         }
   20607                                       else
   20608                                         {
   20609                                           if (((word >> 13) & 0x1) == 0)
   20610                                             {
   20611                                               if (((word >> 14) & 0x1) == 0)
   20612                                                 {
   20613                                                   /* 33222222222211111111110000000000
   20614                                                      10987654321098765432109876543210
   20615                                                      x1x11110xx1xxxxxx00100xxxxxxxxxx
   20616                                                      sqdmlal.  */
   20617                                                   return 422;
   20618                                                 }
   20619                                               else
   20620                                                 {
   20621                                                   /* 33222222222211111111110000000000
   20622                                                      10987654321098765432109876543210
   20623                                                      x1x11110xx1xxxxxx10100xxxxxxxxxx
   20624                                                      sqdmull.  */
   20625                                                   return 424;
   20626                                                 }
   20627                                             }
   20628                                           else
   20629                                             {
   20630                                               /* 33222222222211111111110000000000
   20631                                                  10987654321098765432109876543210
   20632                                                  x1x11110xx1xxxxxxx1100xxxxxxxxxx
   20633                                                  sqdmlsl.  */
   20634                                               return 423;
   20635                                             }
   20636                                         }
   20637                                     }
   20638                                 }
   20639                               else
   20640                                 {
   20641                                   if (((word >> 12) & 0x1) == 0)
   20642                                     {
   20643                                       if (((word >> 13) & 0x1) == 0)
   20644                                         {
   20645                                           if (((word >> 14) & 0x1) == 0)
   20646                                             {
   20647                                               if (((word >> 15) & 0x1) == 0)
   20648                                                 {
   20649                                                   if (((word >> 30) & 0x1) == 0)
   20650                                                     {
   20651                                                       /* 33222222222211111111110000000000
   20652                                                          10987654321098765432109876543210
   20653                                                          x0x11110xx1xxxxx000010xxxxxxxxxx
   20654                                                          fmul.  */
   20655                                                       return 840;
   20656                                                     }
   20657                                                   else
   20658                                                     {
   20659                                                       /* 33222222222211111111110000000000
   20660                                                          10987654321098765432109876543210
   20661                                                          x1x11110xx1xxxxx000010xxxxxxxxxx
   20662                                                          sha1h.  */
   20663                                                       return 675;
   20664                                                     }
   20665                                                 }
   20666                                               else
   20667                                                 {
   20668                                                   if (((word >> 29) & 0x1) == 0)
   20669                                                     {
   20670                                                       if (((word >> 30) & 0x1) == 0)
   20671                                                         {
   20672                                                           /* 33222222222211111111110000000000
   20673                                                              10987654321098765432109876543210
   20674                                                              x0011110xx1xxxxx100010xxxxxxxxxx
   20675                                                              fnmul.  */
   20676                                                           return 856;
   20677                                                         }
   20678                                                       else
   20679                                                         {
   20680                                                           /* 33222222222211111111110000000000
   20681                                                              10987654321098765432109876543210
   20682                                                              x1011110xx1xxxxx100010xxxxxxxxxx
   20683                                                              cmgt.  */
   20684                                                           return 482;
   20685                                                         }
   20686                                                     }
   20687                                                   else
   20688                                                     {
   20689                                                       /* 33222222222211111111110000000000
   20690                                                          10987654321098765432109876543210
   20691                                                          xx111110xx1xxxxx100010xxxxxxxxxx
   20692                                                          cmge.  */
   20693                                                       return 511;
   20694                                                     }
   20695                                                 }
   20696                                             }
   20697                                           else
   20698                                             {
   20699                                               if (((word >> 15) & 0x1) == 0)
   20700                                                 {
   20701                                                   if (((word >> 29) & 0x1) == 0)
   20702                                                     {
   20703                                                       if (((word >> 30) & 0x1) == 0)
   20704                                                         {
   20705                                                           /* 33222222222211111111110000000000
   20706                                                              10987654321098765432109876543210
   20707                                                              x0011110xx1xxxxx010010xxxxxxxxxx
   20708                                                              fmax.  */
   20709                                                           return 848;
   20710                                                         }
   20711                                                       else
   20712                                                         {
   20713                                                           /* 33222222222211111111110000000000
   20714                                                              10987654321098765432109876543210
   20715                                                              x1011110xx1xxxxx010010xxxxxxxxxx
   20716                                                              sqxtn.  */
   20717                                                           return 486;
   20718                                                         }
   20719                                                     }
   20720                                                   else
   20721                                                     {
   20722                                                       /* 33222222222211111111110000000000
   20723                                                          10987654321098765432109876543210
   20724                                                          xx111110xx1xxxxx010010xxxxxxxxxx
   20725                                                          uqxtn.  */
   20726                                                       return 515;
   20727                                                     }
   20728                                                 }
   20729                                               else
   20730                                                 {
   20731                                                   if (((word >> 16) & 0x1) == 0)
   20732                                                     {
   20733                                                       if (((word >> 19) & 0x1) == 0)
   20734                                                         {
   20735                                                           if (((word >> 20) & 0x1) == 0)
   20736                                                             {
   20737                                                               if (((word >> 29) & 0x1) == 0)
   20738                                                                 {
   20739                                                                   /* 33222222222211111111110000000000
   20740                                                                      10987654321098765432109876543210
   20741                                                                      xx011110xx100xx0110010xxxxxxxxxx
   20742                                                                      fcmgt.  */
   20743                                                                   return 495;
   20744                                                                 }
   20745                                                               else
   20746                                                                 {
   20747                                                                   /* 33222222222211111111110000000000
   20748                                                                      10987654321098765432109876543210
   20749                                                                      xx111110xx100xx0110010xxxxxxxxxx
   20750                                                                      fcmge.  */
   20751                                                                   return 525;
   20752                                                                 }
   20753                                                             }
   20754                                                           else
   20755                                                             {
   20756                                                               if (((word >> 23) & 0x1) == 0)
   20757                                                                 {
   20758                                                                   if (((word >> 29) & 0x1) == 0)
   20759                                                                     {
   20760                                                                       /* 33222222222211111111110000000000
   20761                                                                          10987654321098765432109876543210
   20762                                                                          xx0111100x110xx0110010xxxxxxxxxx
   20763                                                                          fmaxnmp.  */
   20764                                                                       return 539;
   20765                                                                     }
   20766                                                                   else
   20767                                                                     {
   20768                                                                       /* 33222222222211111111110000000000
   20769                                                                          10987654321098765432109876543210
   20770                                                                          xx1111100x110xx0110010xxxxxxxxxx
   20771                                                                          fmaxnmp.  */
   20772                                                                       return 538;
   20773                                                                     }
   20774                                                                 }
   20775                                                               else
   20776                                                                 {
   20777                                                                   if (((word >> 29) & 0x1) == 0)
   20778                                                                     {
   20779                                                                       /* 33222222222211111111110000000000
   20780                                                                          10987654321098765432109876543210
   20781                                                                          xx0111101x110xx0110010xxxxxxxxxx
   20782                                                                          fminnmp.  */
   20783                                                                       return 545;
   20784                                                                     }
   20785                                                                   else
   20786                                                                     {
   20787                                                                       /* 33222222222211111111110000000000
   20788                                                                          10987654321098765432109876543210
   20789                                                                          xx1111101x110xx0110010xxxxxxxxxx
   20790                                                                          fminnmp.  */
   20791                                                                       return 544;
   20792                                                                     }
   20793                                                                 }
   20794                                                             }
   20795                                                         }
   20796                                                       else
   20797                                                         {
   20798                                                           if (((word >> 29) & 0x1) == 0)
   20799                                                             {
   20800                                                               /* 33222222222211111111110000000000
   20801                                                                  10987654321098765432109876543210
   20802                                                                  xx011110xx1x1xx0110010xxxxxxxxxx
   20803                                                                  fcmgt.  */
   20804                                                               return 496;
   20805                                                             }
   20806                                                           else
   20807                                                             {
   20808                                                               /* 33222222222211111111110000000000
   20809                                                                  10987654321098765432109876543210
   20810                                                                  xx111110xx1x1xx0110010xxxxxxxxxx
   20811                                                                  fcmge.  */
   20812                                                               return 526;
   20813                                                             }
   20814                                                         }
   20815                                                     }
   20816                                                   else
   20817                                                     {
   20818                                                       if (((word >> 19) & 0x1) == 0)
   20819                                                         {
   20820                                                           if (((word >> 29) & 0x1) == 0)
   20821                                                             {
   20822                                                               /* 33222222222211111111110000000000
   20823                                                                  10987654321098765432109876543210
   20824                                                                  xx011110xx1x0xx1110010xxxxxxxxxx
   20825                                                                  fcvtas.  */
   20826                                                               return 491;
   20827                                                             }
   20828                                                           else
   20829                                                             {
   20830                                                               /* 33222222222211111111110000000000
   20831                                                                  10987654321098765432109876543210
   20832                                                                  xx111110xx1x0xx1110010xxxxxxxxxx
   20833                                                                  fcvtau.  */
   20834                                                               return 521;
   20835                                                             }
   20836                                                         }
   20837                                                       else
   20838                                                         {
   20839                                                           if (((word >> 29) & 0x1) == 0)
   20840                                                             {
   20841                                                               /* 33222222222211111111110000000000
   20842                                                                  10987654321098765432109876543210
   20843                                                                  xx011110xx1x1xx1110010xxxxxxxxxx
   20844                                                                  fcvtas.  */
   20845                                                               return 492;
   20846                                                             }
   20847                                                           else
   20848                                                             {
   20849                                                               /* 33222222222211111111110000000000
   20850                                                                  10987654321098765432109876543210
   20851                                                                  xx111110xx1x1xx1110010xxxxxxxxxx
   20852                                                                  fcvtau.  */
   20853                                                               return 522;
   20854                                                             }
   20855                                                         }
   20856                                                     }
   20857                                                 }
   20858                                             }
   20859                                         }
   20860                                       else
   20861                                         {
   20862                                           if (((word >> 14) & 0x1) == 0)
   20863                                             {
   20864                                               if (((word >> 15) & 0x1) == 0)
   20865                                                 {
   20866                                                   if (((word >> 29) & 0x1) == 0)
   20867                                                     {
   20868                                                       if (((word >> 30) & 0x1) == 0)
   20869                                                         {
   20870                                                           /* 33222222222211111111110000000000
   20871                                                              10987654321098765432109876543210
   20872                                                              x0011110xx1xxxxx001010xxxxxxxxxx
   20873                                                              fadd.  */
   20874                                                           return 844;
   20875                                                         }
   20876                                                       else
   20877                                                         {
   20878                                                           /* 33222222222211111111110000000000
   20879                                                              10987654321098765432109876543210
   20880                                                              x1011110xx1xxxxx001010xxxxxxxxxx
   20881                                                              sha256su0.  */
   20882                                                           return 677;
   20883                                                         }
   20884                                                     }
   20885                                                   else
   20886                                                     {
   20887                                                       /* 33222222222211111111110000000000
   20888                                                          10987654321098765432109876543210
   20889                                                          xx111110xx1xxxxx001010xxxxxxxxxx
   20890                                                          sqxtun.  */
   20891                                                       return 514;
   20892                                                     }
   20893                                                 }
   20894                                               else
   20895                                                 {
   20896                                                   if (((word >> 16) & 0x1) == 0)
   20897                                                     {
   20898                                                       /* 33222222222211111111110000000000
   20899                                                          10987654321098765432109876543210
   20900                                                          xxx11110xx1xxxx0101010xxxxxxxxxx
   20901                                                          cmlt.  */
   20902                                                       return 484;
   20903                                                     }
   20904                                                   else
   20905                                                     {
   20906                                                       if (((word >> 19) & 0x1) == 0)
   20907                                                         {
   20908                                                           if (((word >> 23) & 0x1) == 0)
   20909                                                             {
   20910                                                               if (((word >> 29) & 0x1) == 0)
   20911                                                                 {
   20912                                                                   /* 33222222222211111111110000000000
   20913                                                                      10987654321098765432109876543210
   20914                                                                      xx0111100x1x0xx1101010xxxxxxxxxx
   20915                                                                      fcvtns.  */
   20916                                                                   return 487;
   20917                                                                 }
   20918                                                               else
   20919                                                                 {
   20920                                                                   /* 33222222222211111111110000000000
   20921                                                                      10987654321098765432109876543210
   20922                                                                      xx1111100x1x0xx1101010xxxxxxxxxx
   20923                                                                      fcvtnu.  */
   20924                                                                   return 517;
   20925                                                                 }
   20926                                                             }
   20927                                                           else
   20928                                                             {
   20929                                                               if (((word >> 29) & 0x1) == 0)
   20930                                                                 {
   20931                                                                   /* 33222222222211111111110000000000
   20932                                                                      10987654321098765432109876543210
   20933                                                                      xx0111101x1x0xx1101010xxxxxxxxxx
   20934                                                                      fcvtps.  */
   20935                                                                   return 501;
   20936                                                                 }
   20937                                                               else
   20938                                                                 {
   20939                                                                   /* 33222222222211111111110000000000
   20940                                                                      10987654321098765432109876543210
   20941                                                                      xx1111101x1x0xx1101010xxxxxxxxxx
   20942                                                                      fcvtpu.  */
   20943                                                                   return 529;
   20944                                                                 }
   20945                                                             }
   20946                                                         }
   20947                                                       else
   20948                                                         {
   20949                                                           if (((word >> 23) & 0x1) == 0)
   20950                                                             {
   20951                                                               if (((word >> 29) & 0x1) == 0)
   20952                                                                 {
   20953                                                                   /* 33222222222211111111110000000000
   20954                                                                      10987654321098765432109876543210
   20955                                                                      xx0111100x1x1xx1101010xxxxxxxxxx
   20956                                                                      fcvtns.  */
   20957                                                                   return 488;
   20958                                                                 }
   20959                                                               else
   20960                                                                 {
   20961                                                                   /* 33222222222211111111110000000000
   20962                                                                      10987654321098765432109876543210
   20963                                                                      xx1111100x1x1xx1101010xxxxxxxxxx
   20964                                                                      fcvtnu.  */
   20965                                                                   return 518;
   20966                                                                 }
   20967                                                             }
   20968                                                           else
   20969                                                             {
   20970                                                               if (((word >> 29) & 0x1) == 0)
   20971                                                                 {
   20972                                                                   /* 33222222222211111111110000000000
   20973                                                                      10987654321098765432109876543210
   20974                                                                      xx0111101x1x1xx1101010xxxxxxxxxx
   20975                                                                      fcvtps.  */
   20976                                                                   return 502;
   20977                                                                 }
   20978                                                               else
   20979                                                                 {
   20980                                                                   /* 33222222222211111111110000000000
   20981                                                                      10987654321098765432109876543210
   20982                                                                      xx1111101x1x1xx1101010xxxxxxxxxx
   20983                                                                      fcvtpu.  */
   20984                                                                   return 530;
   20985                                                                 }
   20986                                                             }
   20987                                                         }
   20988                                                     }
   20989                                                 }
   20990                                             }
   20991                                           else
   20992                                             {
   20993                                               if (((word >> 15) & 0x1) == 0)
   20994                                                 {
   20995                                                   if (((word >> 29) & 0x1) == 0)
   20996                                                     {
   20997                                                       /* 33222222222211111111110000000000
   20998                                                          10987654321098765432109876543210
   20999                                                          xx011110xx1xxxxx011010xxxxxxxxxx
   21000                                                          fmaxnm.  */
   21001                                                       return 852;
   21002                                                     }
   21003                                                   else
   21004                                                     {
   21005                                                       /* 33222222222211111111110000000000
   21006                                                          10987654321098765432109876543210
   21007                                                          xx111110xx1xxxxx011010xxxxxxxxxx
   21008                                                          fcvtxn.  */
   21009                                                       return 516;
   21010                                                     }
   21011                                                 }
   21012                                               else
   21013                                                 {
   21014                                                   if (((word >> 19) & 0x1) == 0)
   21015                                                     {
   21016                                                       /* 33222222222211111111110000000000
   21017                                                          10987654321098765432109876543210
   21018                                                          xxx11110xx1x0xxx111010xxxxxxxxxx
   21019                                                          fcmlt.  */
   21020                                                       return 499;
   21021                                                     }
   21022                                                   else
   21023                                                     {
   21024                                                       /* 33222222222211111111110000000000
   21025                                                          10987654321098765432109876543210
   21026                                                          xxx11110xx1x1xxx111010xxxxxxxxxx
   21027                                                          fcmlt.  */
   21028                                                       return 500;
   21029                                                     }
   21030                                                 }
   21031                                             }
   21032                                         }
   21033                                     }
   21034                                   else
   21035                                     {
   21036                                       if (((word >> 13) & 0x1) == 0)
   21037                                         {
   21038                                           if (((word >> 14) & 0x1) == 0)
   21039                                             {
   21040                                               if (((word >> 15) & 0x1) == 0)
   21041                                                 {
   21042                                                   if (((word >> 30) & 0x1) == 0)
   21043                                                     {
   21044                                                       /* 33222222222211111111110000000000
   21045                                                          10987654321098765432109876543210
   21046                                                          x0x11110xx1xxxxx000110xxxxxxxxxx
   21047                                                          fdiv.  */
   21048                                                       return 842;
   21049                                                     }
   21050                                                   else
   21051                                                     {
   21052                                                       /* 33222222222211111111110000000000
   21053                                                          10987654321098765432109876543210
   21054                                                          x1x11110xx1xxxxx000110xxxxxxxxxx
   21055                                                          sha1su1.  */
   21056                                                       return 676;
   21057                                                     }
   21058                                                 }
   21059                                               else
   21060                                                 {
   21061                                                   if (((word >> 29) & 0x1) == 0)
   21062                                                     {
   21063                                                       /* 33222222222211111111110000000000
   21064                                                          10987654321098765432109876543210
   21065                                                          xx011110xx1xxxxx100110xxxxxxxxxx
   21066                                                          cmeq.  */
   21067                                                       return 483;
   21068                                                     }
   21069                                                   else
   21070                                                     {
   21071                                                       /* 33222222222211111111110000000000
   21072                                                          10987654321098765432109876543210
   21073                                                          xx111110xx1xxxxx100110xxxxxxxxxx
   21074                                                          cmle.  */
   21075                                                       return 512;
   21076                                                     }
   21077                                                 }
   21078                                             }
   21079                                           else
   21080                                             {
   21081                                               if (((word >> 15) & 0x1) == 0)
   21082                                                 {
   21083                                                   /* 33222222222211111111110000000000
   21084                                                      10987654321098765432109876543210
   21085                                                      xxx11110xx1xxxxx010110xxxxxxxxxx
   21086                                                      fmin.  */
   21087                                                   return 850;
   21088                                                 }
   21089                                               else
   21090                                                 {
   21091                                                   if (((word >> 16) & 0x1) == 0)
   21092                                                     {
   21093                                                       if (((word >> 19) & 0x1) == 0)
   21094                                                         {
   21095                                                           if (((word >> 20) & 0x1) == 0)
   21096                                                             {
   21097                                                               if (((word >> 29) & 0x1) == 0)
   21098                                                                 {
   21099                                                                   /* 33222222222211111111110000000000
   21100                                                                      10987654321098765432109876543210
   21101                                                                      xx011110xx100xx0110110xxxxxxxxxx
   21102                                                                      fcmeq.  */
   21103                                                                   return 497;
   21104                                                                 }
   21105                                                               else
   21106                                                                 {
   21107                                                                   /* 33222222222211111111110000000000
   21108                                                                      10987654321098765432109876543210
   21109                                                                      xx111110xx100xx0110110xxxxxxxxxx
   21110                                                                      fcmle.  */
   21111                                                                   return 527;
   21112                                                                 }
   21113                                                             }
   21114                                                           else
   21115                                                             {
   21116                                                               if (((word >> 29) & 0x1) == 0)
   21117                                                                 {
   21118                                                                   /* 33222222222211111111110000000000
   21119                                                                      10987654321098765432109876543210
   21120                                                                      xx011110xx110xx0110110xxxxxxxxxx
   21121                                                                      faddp.  */
   21122                                                                   return 541;
   21123                                                                 }
   21124                                                               else
   21125                                                                 {
   21126                                                                   /* 33222222222211111111110000000000
   21127                                                                      10987654321098765432109876543210
   21128                                                                      xx111110xx110xx0110110xxxxxxxxxx
   21129                                                                      faddp.  */
   21130                                                                   return 540;
   21131                                                                 }
   21132                                                             }
   21133                                                         }
   21134                                                       else
   21135                                                         {
   21136                                                           if (((word >> 29) & 0x1) == 0)
   21137                                                             {
   21138                                                               /* 33222222222211111111110000000000
   21139                                                                  10987654321098765432109876543210
   21140                                                                  xx011110xx1x1xx0110110xxxxxxxxxx
   21141                                                                  fcmeq.  */
   21142                                                               return 498;
   21143                                                             }
   21144                                                           else
   21145                                                             {
   21146                                                               /* 33222222222211111111110000000000
   21147                                                                  10987654321098765432109876543210
   21148                                                                  xx111110xx1x1xx0110110xxxxxxxxxx
   21149                                                                  fcmle.  */
   21150                                                               return 528;
   21151                                                             }
   21152                                                         }
   21153                                                     }
   21154                                                   else
   21155                                                     {
   21156                                                       if (((word >> 19) & 0x1) == 0)
   21157                                                         {
   21158                                                           if (((word >> 23) & 0x1) == 0)
   21159                                                             {
   21160                                                               if (((word >> 29) & 0x1) == 0)
   21161                                                                 {
   21162                                                                   /* 33222222222211111111110000000000
   21163                                                                      10987654321098765432109876543210
   21164                                                                      xx0111100x1x0xx1110110xxxxxxxxxx
   21165                                                                      scvtf.  */
   21166                                                                   return 493;
   21167                                                                 }
   21168                                                               else
   21169                                                                 {
   21170                                                                   /* 33222222222211111111110000000000
   21171                                                                      10987654321098765432109876543210
   21172                                                                      xx1111100x1x0xx1110110xxxxxxxxxx
   21173                                                                      ucvtf.  */
   21174                                                                   return 523;
   21175                                                                 }
   21176                                                             }
   21177                                                           else
   21178                                                             {
   21179                                                               if (((word >> 29) & 0x1) == 0)
   21180                                                                 {
   21181                                                                   /* 33222222222211111111110000000000
   21182                                                                      10987654321098765432109876543210
   21183                                                                      xx0111101x1x0xx1110110xxxxxxxxxx
   21184                                                                      frecpe.  */
   21185                                                                   return 505;
   21186                                                                 }
   21187                                                               else
   21188                                                                 {
   21189                                                                   /* 33222222222211111111110000000000
   21190                                                                      10987654321098765432109876543210
   21191                                                                      xx1111101x1x0xx1110110xxxxxxxxxx
   21192                                                                      frsqrte.  */
   21193                                                                   return 533;
   21194                                                                 }
   21195                                                             }
   21196                                                         }
   21197                                                       else
   21198                                                         {
   21199                                                           if (((word >> 23) & 0x1) == 0)
   21200                                                             {
   21201                                                               if (((word >> 29) & 0x1) == 0)
   21202                                                                 {
   21203                                                                   /* 33222222222211111111110000000000
   21204                                                                      10987654321098765432109876543210
   21205                                                                      xx0111100x1x1xx1110110xxxxxxxxxx
   21206                                                                      scvtf.  */
   21207                                                                   return 494;
   21208                                                                 }
   21209                                                               else
   21210                                                                 {
   21211                                                                   /* 33222222222211111111110000000000
   21212                                                                      10987654321098765432109876543210
   21213                                                                      xx1111100x1x1xx1110110xxxxxxxxxx
   21214                                                                      ucvtf.  */
   21215                                                                   return 524;
   21216                                                                 }
   21217                                                             }
   21218                                                           else
   21219                                                             {
   21220                                                               if (((word >> 29) & 0x1) == 0)
   21221                                                                 {
   21222                                                                   /* 33222222222211111111110000000000
   21223                                                                      10987654321098765432109876543210
   21224                                                                      xx0111101x1x1xx1110110xxxxxxxxxx
   21225                                                                      frecpe.  */
   21226                                                                   return 506;
   21227                                                                 }
   21228                                                               else
   21229                                                                 {
   21230                                                                   /* 33222222222211111111110000000000
   21231                                                                      10987654321098765432109876543210
   21232                                                                      xx1111101x1x1xx1110110xxxxxxxxxx
   21233                                                                      frsqrte.  */
   21234                                                                   return 534;
   21235                                                                 }
   21236                                                             }
   21237                                                         }
   21238                                                     }
   21239                                                 }
   21240                                             }
   21241                                         }
   21242                                       else
   21243                                         {
   21244                                           if (((word >> 14) & 0x1) == 0)
   21245                                             {
   21246                                               if (((word >> 15) & 0x1) == 0)
   21247                                                 {
   21248                                                   if (((word >> 29) & 0x1) == 0)
   21249                                                     {
   21250                                                       if (((word >> 30) & 0x1) == 0)
   21251                                                         {
   21252                                                           /* 33222222222211111111110000000000
   21253                                                              10987654321098765432109876543210
   21254                                                              x0011110xx1xxxxx001110xxxxxxxxxx
   21255                                                              fsub.  */
   21256                                                           return 846;
   21257                                                         }
   21258                                                       else
   21259                                                         {
   21260                                                           /* 33222222222211111111110000000000
   21261                                                              10987654321098765432109876543210
   21262                                                              x1011110xx1xxxxx001110xxxxxxxxxx
   21263                                                              suqadd.  */
   21264                                                           return 480;
   21265                                                         }
   21266                                                     }
   21267                                                   else
   21268                                                     {
   21269                                                       /* 33222222222211111111110000000000
   21270                                                          10987654321098765432109876543210
   21271                                                          xx111110xx1xxxxx001110xxxxxxxxxx
   21272                                                          usqadd.  */
   21273                                                       return 509;
   21274                                                     }
   21275                                                 }
   21276                                               else
   21277                                                 {
   21278                                                   if (((word >> 16) & 0x1) == 0)
   21279                                                     {
   21280                                                       if (((word >> 29) & 0x1) == 0)
   21281                                                         {
   21282                                                           /* 33222222222211111111110000000000
   21283                                                              10987654321098765432109876543210
   21284                                                              xx011110xx1xxxx0101110xxxxxxxxxx
   21285                                                              abs.  */
   21286                                                           return 485;
   21287                                                         }
   21288                                                       else
   21289                                                         {
   21290                                                           /* 33222222222211111111110000000000
   21291                                                              10987654321098765432109876543210
   21292                                                              xx111110xx1xxxx0101110xxxxxxxxxx
   21293                                                              neg.  */
   21294                                                           return 513;
   21295                                                         }
   21296                                                     }
   21297                                                   else
   21298                                                     {
   21299                                                       if (((word >> 19) & 0x1) == 0)
   21300                                                         {
   21301                                                           if (((word >> 20) & 0x1) == 0)
   21302                                                             {
   21303                                                               if (((word >> 23) & 0x1) == 0)
   21304                                                                 {
   21305                                                                   if (((word >> 29) & 0x1) == 0)
   21306                                                                     {
   21307                                                                       /* 33222222222211111111110000000000
   21308                                                                          10987654321098765432109876543210
   21309                                                                          xx0111100x100xx1101110xxxxxxxxxx
   21310                                                                          fcvtms.  */
   21311                                                                       return 489;
   21312                                                                     }
   21313                                                                   else
   21314                                                                     {
   21315                                                                       /* 33222222222211111111110000000000
   21316                                                                          10987654321098765432109876543210
   21317                                                                          xx1111100x100xx1101110xxxxxxxxxx
   21318                                                                          fcvtmu.  */
   21319                                                                       return 519;
   21320                                                                     }
   21321                                                                 }
   21322                                                               else
   21323                                                                 {
   21324                                                                   if (((word >> 29) & 0x1) == 0)
   21325                                                                     {
   21326                                                                       /* 33222222222211111111110000000000
   21327                                                                          10987654321098765432109876543210
   21328                                                                          xx0111101x100xx1101110xxxxxxxxxx
   21329                                                                          fcvtzs.  */
   21330                                                                       return 503;
   21331                                                                     }
   21332                                                                   else
   21333                                                                     {
   21334                                                                       /* 33222222222211111111110000000000
   21335                                                                          10987654321098765432109876543210
   21336                                                                          xx1111101x100xx1101110xxxxxxxxxx
   21337                                                                          fcvtzu.  */
   21338                                                                       return 531;
   21339                                                                     }
   21340                                                                 }
   21341                                                             }
   21342                                                           else
   21343                                                             {
   21344                                                               /* 33222222222211111111110000000000
   21345                                                                  10987654321098765432109876543210
   21346                                                                  xxx11110xx110xx1101110xxxxxxxxxx
   21347                                                                  addp.  */
   21348                                                               return 537;
   21349                                                             }
   21350                                                         }
   21351                                                       else
   21352                                                         {
   21353                                                           if (((word >> 23) & 0x1) == 0)
   21354                                                             {
   21355                                                               if (((word >> 29) & 0x1) == 0)
   21356                                                                 {
   21357                                                                   /* 33222222222211111111110000000000
   21358                                                                      10987654321098765432109876543210
   21359                                                                      xx0111100x1x1xx1101110xxxxxxxxxx
   21360                                                                      fcvtms.  */
   21361                                                                   return 490;
   21362                                                                 }
   21363                                                               else
   21364                                                                 {
   21365                                                                   /* 33222222222211111111110000000000
   21366                                                                      10987654321098765432109876543210
   21367                                                                      xx1111100x1x1xx1101110xxxxxxxxxx
   21368                                                                      fcvtmu.  */
   21369                                                                   return 520;
   21370                                                                 }
   21371                                                             }
   21372                                                           else
   21373                                                             {
   21374                                                               if (((word >> 29) & 0x1) == 0)
   21375                                                                 {
   21376                                                                   /* 33222222222211111111110000000000
   21377                                                                      10987654321098765432109876543210
   21378                                                                      xx0111101x1x1xx1101110xxxxxxxxxx
   21379                                                                      fcvtzs.  */
   21380                                                                   return 504;
   21381                                                                 }
   21382                                                               else
   21383                                                                 {
   21384                                                                   /* 33222222222211111111110000000000
   21385                                                                      10987654321098765432109876543210
   21386                                                                      xx1111101x1x1xx1101110xxxxxxxxxx
   21387                                                                      fcvtzu.  */
   21388                                                                   return 532;
   21389                                                                 }
   21390                                                             }
   21391                                                         }
   21392                                                     }
   21393                                                 }
   21394                                             }
   21395                                           else
   21396                                             {
   21397                                               if (((word >> 15) & 0x1) == 0)
   21398                                                 {
   21399                                                   if (((word >> 29) & 0x1) == 0)
   21400                                                     {
   21401                                                       if (((word >> 30) & 0x1) == 0)
   21402                                                         {
   21403                                                           /* 33222222222211111111110000000000
   21404                                                              10987654321098765432109876543210
   21405                                                              x0011110xx1xxxxx011110xxxxxxxxxx
   21406                                                              fminnm.  */
   21407                                                           return 854;
   21408                                                         }
   21409                                                       else
   21410                                                         {
   21411                                                           /* 33222222222211111111110000000000
   21412                                                              10987654321098765432109876543210
   21413                                                              x1011110xx1xxxxx011110xxxxxxxxxx
   21414                                                              sqabs.  */
   21415                                                           return 481;
   21416                                                         }
   21417                                                     }
   21418                                                   else
   21419                                                     {
   21420                                                       /* 33222222222211111111110000000000
   21421                                                          10987654321098765432109876543210
   21422                                                          xx111110xx1xxxxx011110xxxxxxxxxx
   21423                                                          sqneg.  */
   21424                                                       return 510;
   21425                                                     }
   21426                                                 }
   21427                                               else
   21428                                                 {
   21429                                                   if (((word >> 16) & 0x1) == 0)
   21430                                                     {
   21431                                                       if (((word >> 23) & 0x1) == 0)
   21432                                                         {
   21433                                                           if (((word >> 29) & 0x1) == 0)
   21434                                                             {
   21435                                                               /* 33222222222211111111110000000000
   21436                                                                  10987654321098765432109876543210
   21437                                                                  xx0111100x1xxxx0111110xxxxxxxxxx
   21438                                                                  fmaxp.  */
   21439                                                               return 543;
   21440                                                             }
   21441                                                           else
   21442                                                             {
   21443                                                               /* 33222222222211111111110000000000
   21444                                                                  10987654321098765432109876543210
   21445                                                                  xx1111100x1xxxx0111110xxxxxxxxxx
   21446                                                                  fmaxp.  */
   21447                                                               return 542;
   21448                                                             }
   21449                                                         }
   21450                                                       else
   21451                                                         {
   21452                                                           if (((word >> 29) & 0x1) == 0)
   21453                                                             {
   21454                                                               /* 33222222222211111111110000000000
   21455                                                                  10987654321098765432109876543210
   21456                                                                  xx0111101x1xxxx0111110xxxxxxxxxx
   21457                                                                  fminp.  */
   21458                                                               return 547;
   21459                                                             }
   21460                                                           else
   21461                                                             {
   21462                                                               /* 33222222222211111111110000000000
   21463                                                                  10987654321098765432109876543210
   21464                                                                  xx1111101x1xxxx0111110xxxxxxxxxx
   21465                                                                  fminp.  */
   21466                                                               return 546;
   21467                                                             }
   21468                                                         }
   21469                                                     }
   21470                                                   else
   21471                                                     {
   21472                                                       if (((word >> 19) & 0x1) == 0)
   21473                                                         {
   21474                                                           /* 33222222222211111111110000000000
   21475                                                              10987654321098765432109876543210
   21476                                                              xxx11110xx1x0xx1111110xxxxxxxxxx
   21477                                                              frecpx.  */
   21478                                                           return 507;
   21479                                                         }
   21480                                                       else
   21481                                                         {
   21482                                                           /* 33222222222211111111110000000000
   21483                                                              10987654321098765432109876543210
   21484                                                              xxx11110xx1x1xx1111110xxxxxxxxxx
   21485                                                              frecpx.  */
   21486                                                           return 508;
   21487                                                         }
   21488                                                     }
   21489                                                 }
   21490                                             }
   21491                                         }
   21492                                     }
   21493                                 }
   21494                             }
   21495                           else
   21496                             {
   21497                               if (((word >> 11) & 0x1) == 0)
   21498                                 {
   21499                                   if (((word >> 29) & 0x1) == 0)
   21500                                     {
   21501                                       if (((word >> 30) & 0x1) == 0)
   21502                                         {
   21503                                           if (((word >> 4) & 0x1) == 0)
   21504                                             {
   21505                                               /* 33222222222211111111110000000000
   21506                                                  10987654321098765432109876543210
   21507                                                  x0011110xx1xxxxxxxxx01xxxxx0xxxx
   21508                                                  fccmp.  */
   21509                                               return 799;
   21510                                             }
   21511                                           else
   21512                                             {
   21513                                               /* 33222222222211111111110000000000
   21514                                                  10987654321098765432109876543210
   21515                                                  x0011110xx1xxxxxxxxx01xxxxx1xxxx
   21516                                                  fccmpe.  */
   21517                                               return 801;
   21518                                             }
   21519                                         }
   21520                                       else
   21521                                         {
   21522                                           if (((word >> 12) & 0x1) == 0)
   21523                                             {
   21524                                               if (((word >> 13) & 0x1) == 0)
   21525                                                 {
   21526                                                   if (((word >> 14) & 0x1) == 0)
   21527                                                     {
   21528                                                       /* 33222222222211111111110000000000
   21529                                                          10987654321098765432109876543210
   21530                                                          x1011110xx1xxxxxx00001xxxxxxxxxx
   21531                                                          add.  */
   21532                                                       return 565;
   21533                                                     }
   21534                                                   else
   21535                                                     {
   21536                                                       /* 33222222222211111111110000000000
   21537                                                          10987654321098765432109876543210
   21538                                                          x1011110xx1xxxxxx10001xxxxxxxxxx
   21539                                                          sshl.  */
   21540                                                       return 563;
   21541                                                     }
   21542                                                 }
   21543                                               else
   21544                                                 {
   21545                                                   /* 33222222222211111111110000000000
   21546                                                      10987654321098765432109876543210
   21547                                                      x1011110xx1xxxxxxx1001xxxxxxxxxx
   21548                                                      fcmeq.  */
   21549                                                   return 555;
   21550                                                 }
   21551                                             }
   21552                                           else
   21553                                             {
   21554                                               if (((word >> 13) & 0x1) == 0)
   21555                                                 {
   21556                                                   /* 33222222222211111111110000000000
   21557                                                      10987654321098765432109876543210
   21558                                                      x1011110xx1xxxxxxx0101xxxxxxxxxx
   21559                                                      srshl.  */
   21560                                                   return 564;
   21561                                                 }
   21562                                               else
   21563                                                 {
   21564                                                   if (((word >> 15) & 0x1) == 0)
   21565                                                     {
   21566                                                       /* 33222222222211111111110000000000
   21567                                                          10987654321098765432109876543210
   21568                                                          x1011110xx1xxxxx0x1101xxxxxxxxxx
   21569                                                          cmgt.  */
   21570                                                       return 561;
   21571                                                     }
   21572                                                   else
   21573                                                     {
   21574                                                       /* 33222222222211111111110000000000
   21575                                                          10987654321098765432109876543210
   21576                                                          x1011110xx1xxxxx1x1101xxxxxxxxxx
   21577                                                          sqdmulh.  */
   21578                                                       return 552;
   21579                                                     }
   21580                                                 }
   21581                                             }
   21582                                         }
   21583                                     }
   21584                                   else
   21585                                     {
   21586                                       if (((word >> 12) & 0x1) == 0)
   21587                                         {
   21588                                           if (((word >> 13) & 0x1) == 0)
   21589                                             {
   21590                                               if (((word >> 14) & 0x1) == 0)
   21591                                                 {
   21592                                                   /* 33222222222211111111110000000000
   21593                                                      10987654321098765432109876543210
   21594                                                      xx111110xx1xxxxxx00001xxxxxxxxxx
   21595                                                      sub.  */
   21596                                                   return 586;
   21597                                                 }
   21598                                               else
   21599                                                 {
   21600                                                   /* 33222222222211111111110000000000
   21601                                                      10987654321098765432109876543210
   21602                                                      xx111110xx1xxxxxx10001xxxxxxxxxx
   21603                                                      ushl.  */
   21604                                                   return 584;
   21605                                                 }
   21606                                             }
   21607                                           else
   21608                                             {
   21609                                               if (((word >> 23) & 0x1) == 0)
   21610                                                 {
   21611                                                   /* 33222222222211111111110000000000
   21612                                                      10987654321098765432109876543210
   21613                                                      xx1111100x1xxxxxxx1001xxxxxxxxxx
   21614                                                      fcmge.  */
   21615                                                   return 572;
   21616                                                 }
   21617                                               else
   21618                                                 {
   21619                                                   /* 33222222222211111111110000000000
   21620                                                      10987654321098765432109876543210
   21621                                                      xx1111101x1xxxxxxx1001xxxxxxxxxx
   21622                                                      fcmgt.  */
   21623                                                   return 578;
   21624                                                 }
   21625                                             }
   21626                                         }
   21627                                       else
   21628                                         {
   21629                                           if (((word >> 13) & 0x1) == 0)
   21630                                             {
   21631                                               if (((word >> 15) & 0x1) == 0)
   21632                                                 {
   21633                                                   /* 33222222222211111111110000000000
   21634                                                      10987654321098765432109876543210
   21635                                                      xx111110xx1xxxxx0x0101xxxxxxxxxx
   21636                                                      urshl.  */
   21637                                                   return 585;
   21638                                                 }
   21639                                               else
   21640                                                 {
   21641                                                   /* 33222222222211111111110000000000
   21642                                                      10987654321098765432109876543210
   21643                                                      xx111110xx1xxxxx1x0101xxxxxxxxxx
   21644                                                      fabd.  */
   21645                                                   return 576;
   21646                                                 }
   21647                                             }
   21648                                           else
   21649                                             {
   21650                                               if (((word >> 15) & 0x1) == 0)
   21651                                                 {
   21652                                                   /* 33222222222211111111110000000000
   21653                                                      10987654321098765432109876543210
   21654                                                      xx111110xx1xxxxx0x1101xxxxxxxxxx
   21655                                                      cmhi.  */
   21656                                                   return 582;
   21657                                                 }
   21658                                               else
   21659                                                 {
   21660                                                   /* 33222222222211111111110000000000
   21661                                                      10987654321098765432109876543210
   21662                                                      xx111110xx1xxxxx1x1101xxxxxxxxxx
   21663                                                      sqrdmulh.  */
   21664                                                   return 571;
   21665                                                 }
   21666                                             }
   21667                                         }
   21668                                     }
   21669                                 }
   21670                               else
   21671                                 {
   21672                                   if (((word >> 29) & 0x1) == 0)
   21673                                     {
   21674                                       if (((word >> 30) & 0x1) == 0)
   21675                                         {
   21676                                           /* 33222222222211111111110000000000
   21677                                              10987654321098765432109876543210
   21678                                              x0011110xx1xxxxxxxxx11xxxxxxxxxx
   21679                                              fcsel.  */
   21680                                           return 868;
   21681                                         }
   21682                                       else
   21683                                         {
   21684                                           if (((word >> 12) & 0x1) == 0)
   21685                                             {
   21686                                               if (((word >> 13) & 0x1) == 0)
   21687                                                 {
   21688                                                   if (((word >> 14) & 0x1) == 0)
   21689                                                     {
   21690                                                       if (((word >> 15) & 0x1) == 0)
   21691                                                         {
   21692                                                           /* 33222222222211111111110000000000
   21693                                                              10987654321098765432109876543210
   21694                                                              x1011110xx1xxxxx000011xxxxxxxxxx
   21695                                                              sqadd.  */
   21696                                                           return 548;
   21697                                                         }
   21698                                                       else
   21699                                                         {
   21700                                                           /* 33222222222211111111110000000000
   21701                                                              10987654321098765432109876543210
   21702                                                              x1011110xx1xxxxx100011xxxxxxxxxx
   21703                                                              cmtst.  */
   21704                                                           return 566;
   21705                                                         }
   21706                                                     }
   21707                                                   else
   21708                                                     {
   21709                                                       /* 33222222222211111111110000000000
   21710                                                          10987654321098765432109876543210
   21711                                                          x1011110xx1xxxxxx10011xxxxxxxxxx
   21712                                                          sqshl.  */
   21713                                                       return 550;
   21714                                                     }
   21715                                                 }
   21716                                               else
   21717                                                 {
   21718                                                   /* 33222222222211111111110000000000
   21719                                                      10987654321098765432109876543210
   21720                                                      x1011110xx1xxxxxxx1011xxxxxxxxxx
   21721                                                      sqsub.  */
   21722                                                   return 549;
   21723                                                 }
   21724                                             }
   21725                                           else
   21726                                             {
   21727                                               if (((word >> 13) & 0x1) == 0)
   21728                                                 {
   21729                                                   if (((word >> 15) & 0x1) == 0)
   21730                                                     {
   21731                                                       /* 33222222222211111111110000000000
   21732                                                          10987654321098765432109876543210
   21733                                                          x1011110xx1xxxxx0x0111xxxxxxxxxx
   21734                                                          sqrshl.  */
   21735                                                       return 551;
   21736                                                     }
   21737                                                   else
   21738                                                     {
   21739                                                       /* 33222222222211111111110000000000
   21740                                                          10987654321098765432109876543210
   21741                                                          x1011110xx1xxxxx1x0111xxxxxxxxxx
   21742                                                          fmulx.  */
   21743                                                       return 553;
   21744                                                     }
   21745                                                 }
   21746                                               else
   21747                                                 {
   21748                                                   if (((word >> 14) & 0x1) == 0)
   21749                                                     {
   21750                                                       /* 33222222222211111111110000000000
   21751                                                          10987654321098765432109876543210
   21752                                                          x1011110xx1xxxxxx01111xxxxxxxxxx
   21753                                                          cmge.  */
   21754                                                       return 562;
   21755                                                     }
   21756                                                   else
   21757                                                     {
   21758                                                       if (((word >> 23) & 0x1) == 0)
   21759                                                         {
   21760                                                           /* 33222222222211111111110000000000
   21761                                                              10987654321098765432109876543210
   21762                                                              x10111100x1xxxxxx11111xxxxxxxxxx
   21763                                                              frecps.  */
   21764                                                           return 557;
   21765                                                         }
   21766                                                       else
   21767                                                         {
   21768                                                           /* 33222222222211111111110000000000
   21769                                                              10987654321098765432109876543210
   21770                                                              x10111101x1xxxxxx11111xxxxxxxxxx
   21771                                                              frsqrts.  */
   21772                                                           return 559;
   21773                                                         }
   21774                                                     }
   21775                                                 }
   21776                                             }
   21777                                         }
   21778                                     }
   21779                                   else
   21780                                     {
   21781                                       if (((word >> 12) & 0x1) == 0)
   21782                                         {
   21783                                           if (((word >> 13) & 0x1) == 0)
   21784                                             {
   21785                                               if (((word >> 14) & 0x1) == 0)
   21786                                                 {
   21787                                                   if (((word >> 15) & 0x1) == 0)
   21788                                                     {
   21789                                                       /* 33222222222211111111110000000000
   21790                                                          10987654321098765432109876543210
   21791                                                          xx111110xx1xxxxx000011xxxxxxxxxx
   21792                                                          uqadd.  */
   21793                                                       return 567;
   21794                                                     }
   21795                                                   else
   21796                                                     {
   21797                                                       /* 33222222222211111111110000000000
   21798                                                          10987654321098765432109876543210
   21799                                                          xx111110xx1xxxxx100011xxxxxxxxxx
   21800                                                          cmeq.  */
   21801                                                       return 587;
   21802                                                     }
   21803                                                 }
   21804                                               else
   21805                                                 {
   21806                                                   /* 33222222222211111111110000000000
   21807                                                      10987654321098765432109876543210
   21808                                                      xx111110xx1xxxxxx10011xxxxxxxxxx
   21809                                                      uqshl.  */
   21810                                                   return 569;
   21811                                                 }
   21812                                             }
   21813                                           else
   21814                                             {
   21815                                               if (((word >> 14) & 0x1) == 0)
   21816                                                 {
   21817                                                   /* 33222222222211111111110000000000
   21818                                                      10987654321098765432109876543210
   21819                                                      xx111110xx1xxxxxx01011xxxxxxxxxx
   21820                                                      uqsub.  */
   21821                                                   return 568;
   21822                                                 }
   21823                                               else
   21824                                                 {
   21825                                                   if (((word >> 23) & 0x1) == 0)
   21826                                                     {
   21827                                                       /* 33222222222211111111110000000000
   21828                                                          10987654321098765432109876543210
   21829                                                          xx1111100x1xxxxxx11011xxxxxxxxxx
   21830                                                          facge.  */
   21831                                                       return 574;
   21832                                                     }
   21833                                                   else
   21834                                                     {
   21835                                                       /* 33222222222211111111110000000000
   21836                                                          10987654321098765432109876543210
   21837                                                          xx1111101x1xxxxxx11011xxxxxxxxxx
   21838                                                          facgt.  */
   21839                                                       return 580;
   21840                                                     }
   21841                                                 }
   21842                                             }
   21843                                         }
   21844                                       else
   21845                                         {
   21846                                           if (((word >> 13) & 0x1) == 0)
   21847                                             {
   21848                                               /* 33222222222211111111110000000000
   21849                                                  10987654321098765432109876543210
   21850                                                  xx111110xx1xxxxxxx0111xxxxxxxxxx
   21851                                                  uqrshl.  */
   21852                                               return 570;
   21853                                             }
   21854                                           else
   21855                                             {
   21856                                               /* 33222222222211111111110000000000
   21857                                                  10987654321098765432109876543210
   21858                                                  xx111110xx1xxxxxxx1111xxxxxxxxxx
   21859                                                  cmhs.  */
   21860                                               return 583;
   21861                                             }
   21862                                         }
   21863                                     }
   21864                                 }
   21865                             }
   21866                         }
   21867                     }
   21868                 }
   21869               else
   21870                 {
   21871                   if (((word >> 15) & 0x1) == 0)
   21872                     {
   21873                       if (((word >> 28) & 0x1) == 0)
   21874                         {
   21875                           if (((word >> 10) & 0x1) == 0)
   21876                             {
   21877                               if (((word >> 12) & 0x1) == 0)
   21878                                 {
   21879                                   if (((word >> 13) & 0x1) == 0)
   21880                                     {
   21881                                       if (((word >> 14) & 0x1) == 0)
   21882                                         {
   21883                                           if (((word >> 29) & 0x1) == 0)
   21884                                             {
   21885                                               if (((word >> 30) & 0x1) == 0)
   21886                                                 {
   21887                                                   /* 33222222222211111111110000000000
   21888                                                      10987654321098765432109876543210
   21889                                                      x0001111xxxxxxxx0000x0xxxxxxxxxx
   21890                                                      fmlal.  */
   21891                                                   return 2370;
   21892                                                 }
   21893                                               else
   21894                                                 {
   21895                                                   /* 33222222222211111111110000000000
   21896                                                      10987654321098765432109876543210
   21897                                                      x1001111xxxxxxxx0000x0xxxxxxxxxx
   21898                                                      fmlal.  */
   21899                                                   return 2374;
   21900                                                 }
   21901                                             }
   21902                                           else
   21903                                             {
   21904                                               /* 33222222222211111111110000000000
   21905                                                  10987654321098765432109876543210
   21906                                                  xx101111xxxxxxxx0000x0xxxxxxxxxx
   21907                                                  mla.  */
   21908                                               return 119;
   21909                                             }
   21910                                         }
   21911                                       else
   21912                                         {
   21913                                           if (((word >> 29) & 0x1) == 0)
   21914                                             {
   21915                                               if (((word >> 30) & 0x1) == 0)
   21916                                                 {
   21917                                                   /* 33222222222211111111110000000000
   21918                                                      10987654321098765432109876543210
   21919                                                      x0001111xxxxxxxx0100x0xxxxxxxxxx
   21920                                                      fmlsl.  */
   21921                                                   return 2371;
   21922                                                 }
   21923                                               else
   21924                                                 {
   21925                                                   /* 33222222222211111111110000000000
   21926                                                      10987654321098765432109876543210
   21927                                                      x1001111xxxxxxxx0100x0xxxxxxxxxx
   21928                                                      fmlsl.  */
   21929                                                   return 2375;
   21930                                                 }
   21931                                             }
   21932                                           else
   21933                                             {
   21934                                               /* 33222222222211111111110000000000
   21935                                                  10987654321098765432109876543210
   21936                                                  xx101111xxxxxxxx0100x0xxxxxxxxxx
   21937                                                  mls.  */
   21938                                               return 122;
   21939                                             }
   21940                                         }
   21941                                     }
   21942                                   else
   21943                                     {
   21944                                       if (((word >> 14) & 0x1) == 0)
   21945                                         {
   21946                                           if (((word >> 29) & 0x1) == 0)
   21947                                             {
   21948                                               if (((word >> 30) & 0x1) == 0)
   21949                                                 {
   21950                                                   /* 33222222222211111111110000000000
   21951                                                      10987654321098765432109876543210
   21952                                                      x0001111xxxxxxxx0010x0xxxxxxxxxx
   21953                                                      smlal.  */
   21954                                                   return 98;
   21955                                                 }
   21956                                               else
   21957                                                 {
   21958                                                   /* 33222222222211111111110000000000
   21959                                                      10987654321098765432109876543210
   21960                                                      x1001111xxxxxxxx0010x0xxxxxxxxxx
   21961                                                      smlal2.  */
   21962                                                   return 99;
   21963                                                 }
   21964                                             }
   21965                                           else
   21966                                             {
   21967                                               if (((word >> 30) & 0x1) == 0)
   21968                                                 {
   21969                                                   /* 33222222222211111111110000000000
   21970                                                      10987654321098765432109876543210
   21971                                                      x0101111xxxxxxxx0010x0xxxxxxxxxx
   21972                                                      umlal.  */
   21973                                                   return 120;
   21974                                                 }
   21975                                               else
   21976                                                 {
   21977                                                   /* 33222222222211111111110000000000
   21978                                                      10987654321098765432109876543210
   21979                                                      x1101111xxxxxxxx0010x0xxxxxxxxxx
   21980                                                      umlal2.  */
   21981                                                   return 121;
   21982                                                 }
   21983                                             }
   21984                                         }
   21985                                       else
   21986                                         {
   21987                                           if (((word >> 29) & 0x1) == 0)
   21988                                             {
   21989                                               if (((word >> 30) & 0x1) == 0)
   21990                                                 {
   21991                                                   /* 33222222222211111111110000000000
   21992                                                      10987654321098765432109876543210
   21993                                                      x0001111xxxxxxxx0110x0xxxxxxxxxx
   21994                                                      smlsl.  */
   21995                                                   return 102;
   21996                                                 }
   21997                                               else
   21998                                                 {
   21999                                                   /* 33222222222211111111110000000000
   22000                                                      10987654321098765432109876543210
   22001                                                      x1001111xxxxxxxx0110x0xxxxxxxxxx
   22002                                                      smlsl2.  */
   22003                                                   return 103;
   22004                                                 }
   22005                                             }
   22006                                           else
   22007                                             {
   22008                                               if (((word >> 30) & 0x1) == 0)
   22009                                                 {
   22010                                                   /* 33222222222211111111110000000000
   22011                                                      10987654321098765432109876543210
   22012                                                      x0101111xxxxxxxx0110x0xxxxxxxxxx
   22013                                                      umlsl.  */
   22014                                                   return 123;
   22015                                                 }
   22016                                               else
   22017                                                 {
   22018                                                   /* 33222222222211111111110000000000
   22019                                                      10987654321098765432109876543210
   22020                                                      x1101111xxxxxxxx0110x0xxxxxxxxxx
   22021                                                      umlsl2.  */
   22022                                                   return 124;
   22023                                                 }
   22024                                             }
   22025                                         }
   22026                                     }
   22027                                 }
   22028                               else
   22029                                 {
   22030                                   if (((word >> 29) & 0x1) == 0)
   22031                                     {
   22032                                       if (((word >> 13) & 0x1) == 0)
   22033                                         {
   22034                                           if (((word >> 14) & 0x1) == 0)
   22035                                             {
   22036                                               if (((word >> 23) & 0x1) == 0)
   22037                                                 {
   22038                                                   /* 33222222222211111111110000000000
   22039                                                      10987654321098765432109876543210
   22040                                                      xx0011110xxxxxxx0001x0xxxxxxxxxx
   22041                                                      fmla.  */
   22042                                                   return 114;
   22043                                                 }
   22044                                               else
   22045                                                 {
   22046                                                   /* 33222222222211111111110000000000
   22047                                                      10987654321098765432109876543210
   22048                                                      xx0011111xxxxxxx0001x0xxxxxxxxxx
   22049                                                      fmla.  */
   22050                                                   return 113;
   22051                                                 }
   22052                                             }
   22053                                           else
   22054                                             {
   22055                                               if (((word >> 23) & 0x1) == 0)
   22056                                                 {
   22057                                                   /* 33222222222211111111110000000000
   22058                                                      10987654321098765432109876543210
   22059                                                      xx0011110xxxxxxx0101x0xxxxxxxxxx
   22060                                                      fmls.  */
   22061                                                   return 116;
   22062                                                 }
   22063                                               else
   22064                                                 {
   22065                                                   /* 33222222222211111111110000000000
   22066                                                      10987654321098765432109876543210
   22067                                                      xx0011111xxxxxxx0101x0xxxxxxxxxx
   22068                                                      fmls.  */
   22069                                                   return 115;
   22070                                                 }
   22071                                             }
   22072                                         }
   22073                                       else
   22074                                         {
   22075                                           if (((word >> 14) & 0x1) == 0)
   22076                                             {
   22077                                               if (((word >> 30) & 0x1) == 0)
   22078                                                 {
   22079                                                   /* 33222222222211111111110000000000
   22080                                                      10987654321098765432109876543210
   22081                                                      x0001111xxxxxxxx0011x0xxxxxxxxxx
   22082                                                      sqdmlal.  */
   22083                                                   return 100;
   22084                                                 }
   22085                                               else
   22086                                                 {
   22087                                                   /* 33222222222211111111110000000000
   22088                                                      10987654321098765432109876543210
   22089                                                      x1001111xxxxxxxx0011x0xxxxxxxxxx
   22090                                                      sqdmlal2.  */
   22091                                                   return 101;
   22092                                                 }
   22093                                             }
   22094                                           else
   22095                                             {
   22096                                               if (((word >> 30) & 0x1) == 0)
   22097                                                 {
   22098                                                   /* 33222222222211111111110000000000
   22099                                                      10987654321098765432109876543210
   22100                                                      x0001111xxxxxxxx0111x0xxxxxxxxxx
   22101                                                      sqdmlsl.  */
   22102                                                   return 104;
   22103                                                 }
   22104                                               else
   22105                                                 {
   22106                                                   /* 33222222222211111111110000000000
   22107                                                      10987654321098765432109876543210
   22108                                                      x1001111xxxxxxxx0111x0xxxxxxxxxx
   22109                                                      sqdmlsl2.  */
   22110                                                   return 105;
   22111                                                 }
   22112                                             }
   22113                                         }
   22114                                     }
   22115                                   else
   22116                                     {
   22117                                       /* 33222222222211111111110000000000
   22118                                          10987654321098765432109876543210
   22119                                          xx101111xxxxxxxx0xx1x0xxxxxxxxxx
   22120                                          fcmla.  */
   22121                                       return 131;
   22122                                     }
   22123                                 }
   22124                             }
   22125                           else
   22126                             {
   22127                               if (((word >> 12) & 0x1) == 0)
   22128                                 {
   22129                                   if (((word >> 29) & 0x1) == 0)
   22130                                     {
   22131                                       /* 33222222222211111111110000000000
   22132                                          10987654321098765432109876543210
   22133                                          xx001111xxxxxxxx0xx0x1xxxxxxxxxx
   22134                                          movi.  */
   22135                                       return 133;
   22136                                     }
   22137                                   else
   22138                                     {
   22139                                       /* 33222222222211111111110000000000
   22140                                          10987654321098765432109876543210
   22141                                          xx101111xxxxxxxx0xx0x1xxxxxxxxxx
   22142                                          mvni.  */
   22143                                       return 141;
   22144                                     }
   22145                                 }
   22146                               else
   22147                                 {
   22148                                   if (((word >> 29) & 0x1) == 0)
   22149                                     {
   22150                                       /* 33222222222211111111110000000000
   22151                                          10987654321098765432109876543210
   22152                                          xx001111xxxxxxxx0xx1x1xxxxxxxxxx
   22153                                          orr.  */
   22154                                       return 134;
   22155                                     }
   22156                                   else
   22157                                     {
   22158                                       /* 33222222222211111111110000000000
   22159                                          10987654321098765432109876543210
   22160                                          xx101111xxxxxxxx0xx1x1xxxxxxxxxx
   22161                                          bic.  */
   22162                                       return 142;
   22163                                     }
   22164                                 }
   22165                             }
   22166                         }
   22167                       else
   22168                         {
   22169                           if (((word >> 29) & 0x1) == 0)
   22170                             {
   22171                               if (((word >> 30) & 0x1) == 0)
   22172                                 {
   22173                                   if (((word >> 21) & 0x1) == 0)
   22174                                     {
   22175                                       /* 33222222222211111111110000000000
   22176                                          10987654321098765432109876543210
   22177                                          x0011111xx0xxxxx0xxxxxxxxxxxxxxx
   22178                                          fmadd.  */
   22179                                       return 858;
   22180                                     }
   22181                                   else
   22182                                     {
   22183                                       /* 33222222222211111111110000000000
   22184                                          10987654321098765432109876543210
   22185                                          x0011111xx1xxxxx0xxxxxxxxxxxxxxx
   22186                                          fnmadd.  */
   22187                                       return 862;
   22188                                     }
   22189                                 }
   22190                               else
   22191                                 {
   22192                                   if (((word >> 10) & 0x1) == 0)
   22193                                     {
   22194                                       if (((word >> 13) & 0x1) == 0)
   22195                                         {
   22196                                           if (((word >> 14) & 0x1) == 0)
   22197                                             {
   22198                                               if (((word >> 23) & 0x1) == 0)
   22199                                                 {
   22200                                                   /* 33222222222211111111110000000000
   22201                                                      10987654321098765432109876543210
   22202                                                      x10111110xxxxxxx000xx0xxxxxxxxxx
   22203                                                      fmla.  */
   22204                                                   return 431;
   22205                                                 }
   22206                                               else
   22207                                                 {
   22208                                                   /* 33222222222211111111110000000000
   22209                                                      10987654321098765432109876543210
   22210                                                      x10111111xxxxxxx000xx0xxxxxxxxxx
   22211                                                      fmla.  */
   22212                                                   return 430;
   22213                                                 }
   22214                                             }
   22215                                           else
   22216                                             {
   22217                                               if (((word >> 23) & 0x1) == 0)
   22218                                                 {
   22219                                                   /* 33222222222211111111110000000000
   22220                                                      10987654321098765432109876543210
   22221                                                      x10111110xxxxxxx010xx0xxxxxxxxxx
   22222                                                      fmls.  */
   22223                                                   return 433;
   22224                                                 }
   22225                                               else
   22226                                                 {
   22227                                                   /* 33222222222211111111110000000000
   22228                                                      10987654321098765432109876543210
   22229                                                      x10111111xxxxxxx010xx0xxxxxxxxxx
   22230                                                      fmls.  */
   22231                                                   return 432;
   22232                                                 }
   22233                                             }
   22234                                         }
   22235                                       else
   22236                                         {
   22237                                           if (((word >> 14) & 0x1) == 0)
   22238                                             {
   22239                                               /* 33222222222211111111110000000000
   22240                                                  10987654321098765432109876543210
   22241                                                  x1011111xxxxxxxx001xx0xxxxxxxxxx
   22242                                                  sqdmlal.  */
   22243                                               return 425;
   22244                                             }
   22245                                           else
   22246                                             {
   22247                                               /* 33222222222211111111110000000000
   22248                                                  10987654321098765432109876543210
   22249                                                  x1011111xxxxxxxx011xx0xxxxxxxxxx
   22250                                                  sqdmlsl.  */
   22251                                               return 426;
   22252                                             }
   22253                                         }
   22254                                     }
   22255                                   else
   22256                                     {
   22257                                       if (((word >> 12) & 0x1) == 0)
   22258                                         {
   22259                                           if (((word >> 13) & 0x1) == 0)
   22260                                             {
   22261                                               /* 33222222222211111111110000000000
   22262                                                  10987654321098765432109876543210
   22263                                                  x1011111xxxxxxxx0x00x1xxxxxxxxxx
   22264                                                  sshr.  */
   22265                                               return 590;
   22266                                             }
   22267                                           else
   22268                                             {
   22269                                               /* 33222222222211111111110000000000
   22270                                                  10987654321098765432109876543210
   22271                                                  x1011111xxxxxxxx0x10x1xxxxxxxxxx
   22272                                                  srshr.  */
   22273                                               return 592;
   22274                                             }
   22275                                         }
   22276                                       else
   22277                                         {
   22278                                           if (((word >> 13) & 0x1) == 0)
   22279                                             {
   22280                                               if (((word >> 14) & 0x1) == 0)
   22281                                                 {
   22282                                                   /* 33222222222211111111110000000000
   22283                                                      10987654321098765432109876543210
   22284                                                      x1011111xxxxxxxx0001x1xxxxxxxxxx
   22285                                                      ssra.  */
   22286                                                   return 591;
   22287                                                 }
   22288                                               else
   22289                                                 {
   22290                                                   /* 33222222222211111111110000000000
   22291                                                      10987654321098765432109876543210
   22292                                                      x1011111xxxxxxxx0101x1xxxxxxxxxx
   22293                                                      shl.  */
   22294                                                   return 594;
   22295                                                 }
   22296                                             }
   22297                                           else
   22298                                             {
   22299                                               if (((word >> 14) & 0x1) == 0)
   22300                                                 {
   22301                                                   /* 33222222222211111111110000000000
   22302                                                      10987654321098765432109876543210
   22303                                                      x1011111xxxxxxxx0011x1xxxxxxxxxx
   22304                                                      srsra.  */
   22305                                                   return 593;
   22306                                                 }
   22307                                               else
   22308                                                 {
   22309                                                   /* 33222222222211111111110000000000
   22310                                                      10987654321098765432109876543210
   22311                                                      x1011111xxxxxxxx0111x1xxxxxxxxxx
   22312                                                      sqshl.  */
   22313                                                   return 595;
   22314                                                 }
   22315                                             }
   22316                                         }
   22317                                     }
   22318                                 }
   22319                             }
   22320                           else
   22321                             {
   22322                               if (((word >> 12) & 0x1) == 0)
   22323                                 {
   22324                                   if (((word >> 13) & 0x1) == 0)
   22325                                     {
   22326                                       if (((word >> 14) & 0x1) == 0)
   22327                                         {
   22328                                           /* 33222222222211111111110000000000
   22329                                              10987654321098765432109876543210
   22330                                              xx111111xxxxxxxx0000xxxxxxxxxxxx
   22331                                              ushr.  */
   22332                                           return 602;
   22333                                         }
   22334                                       else
   22335                                         {
   22336                                           /* 33222222222211111111110000000000
   22337                                              10987654321098765432109876543210
   22338                                              xx111111xxxxxxxx0100xxxxxxxxxxxx
   22339                                              sri.  */
   22340                                           return 606;
   22341                                         }
   22342                                     }
   22343                                   else
   22344                                     {
   22345                                       if (((word >> 14) & 0x1) == 0)
   22346                                         {
   22347                                           /* 33222222222211111111110000000000
   22348                                              10987654321098765432109876543210
   22349                                              xx111111xxxxxxxx0010xxxxxxxxxxxx
   22350                                              urshr.  */
   22351                                           return 604;
   22352                                         }
   22353                                       else
   22354                                         {
   22355                                           /* 33222222222211111111110000000000
   22356                                              10987654321098765432109876543210
   22357                                              xx111111xxxxxxxx0110xxxxxxxxxxxx
   22358                                              sqshlu.  */
   22359                                           return 608;
   22360                                         }
   22361                                     }
   22362                                 }
   22363                               else
   22364                                 {
   22365                                   if (((word >> 13) & 0x1) == 0)
   22366                                     {
   22367                                       if (((word >> 14) & 0x1) == 0)
   22368                                         {
   22369                                           /* 33222222222211111111110000000000
   22370                                              10987654321098765432109876543210
   22371                                              xx111111xxxxxxxx0001xxxxxxxxxxxx
   22372                                              usra.  */
   22373                                           return 603;
   22374                                         }
   22375                                       else
   22376                                         {
   22377                                           /* 33222222222211111111110000000000
   22378                                              10987654321098765432109876543210
   22379                                              xx111111xxxxxxxx0101xxxxxxxxxxxx
   22380                                              sli.  */
   22381                                           return 607;
   22382                                         }
   22383                                     }
   22384                                   else
   22385                                     {
   22386                                       if (((word >> 14) & 0x1) == 0)
   22387                                         {
   22388                                           /* 33222222222211111111110000000000
   22389                                              10987654321098765432109876543210
   22390                                              xx111111xxxxxxxx0011xxxxxxxxxxxx
   22391                                              ursra.  */
   22392                                           return 605;
   22393                                         }
   22394                                       else
   22395                                         {
   22396                                           /* 33222222222211111111110000000000
   22397                                              10987654321098765432109876543210
   22398                                              xx111111xxxxxxxx0111xxxxxxxxxxxx
   22399                                              uqshl.  */
   22400                                           return 609;
   22401                                         }
   22402                                     }
   22403                                 }
   22404                             }
   22405                         }
   22406                     }
   22407                   else
   22408                     {
   22409                       if (((word >> 28) & 0x1) == 0)
   22410                         {
   22411                           if (((word >> 10) & 0x1) == 0)
   22412                             {
   22413                               if (((word >> 12) & 0x1) == 0)
   22414                                 {
   22415                                   if (((word >> 13) & 0x1) == 0)
   22416                                     {
   22417                                       if (((word >> 14) & 0x1) == 0)
   22418                                         {
   22419                                           if (((word >> 29) & 0x1) == 0)
   22420                                             {
   22421                                               /* 33222222222211111111110000000000
   22422                                                  10987654321098765432109876543210
   22423                                                  xx001111xxxxxxxx1000x0xxxxxxxxxx
   22424                                                  mul.  */
   22425                                               return 106;
   22426                                             }
   22427                                           else
   22428                                             {
   22429                                               if (((word >> 30) & 0x1) == 0)
   22430                                                 {
   22431                                                   /* 33222222222211111111110000000000
   22432                                                      10987654321098765432109876543210
   22433                                                      x0101111xxxxxxxx1000x0xxxxxxxxxx
   22434                                                      fmlal2.  */
   22435                                                   return 2372;
   22436                                                 }
   22437                                               else
   22438                                                 {
   22439                                                   /* 33222222222211111111110000000000
   22440                                                      10987654321098765432109876543210
   22441                                                      x1101111xxxxxxxx1000x0xxxxxxxxxx
   22442                                                      fmlal2.  */
   22443                                                   return 2376;
   22444                                                 }
   22445                                             }
   22446                                         }
   22447                                       else
   22448                                         {
   22449                                           if (((word >> 29) & 0x1) == 0)
   22450                                             {
   22451                                               /* 33222222222211111111110000000000
   22452                                                  10987654321098765432109876543210
   22453                                                  xx001111xxxxxxxx1100x0xxxxxxxxxx
   22454                                                  sqdmulh.  */
   22455                                               return 111;
   22456                                             }
   22457                                           else
   22458                                             {
   22459                                               if (((word >> 30) & 0x1) == 0)
   22460                                                 {
   22461                                                   /* 33222222222211111111110000000000
   22462                                                      10987654321098765432109876543210
   22463                                                      x0101111xxxxxxxx1100x0xxxxxxxxxx
   22464                                                      fmlsl2.  */
   22465                                                   return 2373;
   22466                                                 }
   22467                                               else
   22468                                                 {
   22469                                                   /* 33222222222211111111110000000000
   22470                                                      10987654321098765432109876543210
   22471                                                      x1101111xxxxxxxx1100x0xxxxxxxxxx
   22472                                                      fmlsl2.  */
   22473                                                   return 2377;
   22474                                                 }
   22475                                             }
   22476                                         }
   22477                                     }
   22478                                   else
   22479                                     {
   22480                                       if (((word >> 14) & 0x1) == 0)
   22481                                         {
   22482                                           if (((word >> 29) & 0x1) == 0)
   22483                                             {
   22484                                               if (((word >> 30) & 0x1) == 0)
   22485                                                 {
   22486                                                   /* 33222222222211111111110000000000
   22487                                                      10987654321098765432109876543210
   22488                                                      x0001111xxxxxxxx1010x0xxxxxxxxxx
   22489                                                      smull.  */
   22490                                                   return 107;
   22491                                                 }
   22492                                               else
   22493                                                 {
   22494                                                   /* 33222222222211111111110000000000
   22495                                                      10987654321098765432109876543210
   22496                                                      x1001111xxxxxxxx1010x0xxxxxxxxxx
   22497                                                      smull2.  */
   22498                                                   return 108;
   22499                                                 }
   22500                                             }
   22501                                           else
   22502                                             {
   22503                                               if (((word >> 30) & 0x1) == 0)
   22504                                                 {
   22505                                                   /* 33222222222211111111110000000000
   22506                                                      10987654321098765432109876543210
   22507                                                      x0101111xxxxxxxx1010x0xxxxxxxxxx
   22508                                                      umull.  */
   22509                                                   return 125;
   22510                                                 }
   22511                                               else
   22512                                                 {
   22513                                                   /* 33222222222211111111110000000000
   22514                                                      10987654321098765432109876543210
   22515                                                      x1101111xxxxxxxx1010x0xxxxxxxxxx
   22516                                                      umull2.  */
   22517                                                   return 126;
   22518                                                 }
   22519                                             }
   22520                                         }
   22521                                       else
   22522                                         {
   22523                                           if (((word >> 29) & 0x1) == 0)
   22524                                             {
   22525                                               /* 33222222222211111111110000000000
   22526                                                  10987654321098765432109876543210
   22527                                                  xx001111xxxxxxxx1110x0xxxxxxxxxx
   22528                                                  sdot.  */
   22529                                               return 2344;
   22530                                             }
   22531                                           else
   22532                                             {
   22533                                               /* 33222222222211111111110000000000
   22534                                                  10987654321098765432109876543210
   22535                                                  xx101111xxxxxxxx1110x0xxxxxxxxxx
   22536                                                  udot.  */
   22537                                               return 2343;
   22538                                             }
   22539                                         }
   22540                                     }
   22541                                 }
   22542                               else
   22543                                 {
   22544                                   if (((word >> 13) & 0x1) == 0)
   22545                                     {
   22546                                       if (((word >> 14) & 0x1) == 0)
   22547                                         {
   22548                                           if (((word >> 23) & 0x1) == 0)
   22549                                             {
   22550                                               if (((word >> 29) & 0x1) == 0)
   22551                                                 {
   22552                                                   /* 33222222222211111111110000000000
   22553                                                      10987654321098765432109876543210
   22554                                                      xx0011110xxxxxxx1001x0xxxxxxxxxx
   22555                                                      fmul.  */
   22556                                                   return 118;
   22557                                                 }
   22558                                               else
   22559                                                 {
   22560                                                   /* 33222222222211111111110000000000
   22561                                                      10987654321098765432109876543210
   22562                                                      xx1011110xxxxxxx1001x0xxxxxxxxxx
   22563                                                      fmulx.  */
   22564                                                   return 128;
   22565                                                 }
   22566                                             }
   22567                                           else
   22568                                             {
   22569                                               if (((word >> 29) & 0x1) == 0)
   22570                                                 {
   22571                                                   /* 33222222222211111111110000000000
   22572                                                      10987654321098765432109876543210
   22573                                                      xx0011111xxxxxxx1001x0xxxxxxxxxx
   22574                                                      fmul.  */
   22575                                                   return 117;
   22576                                                 }
   22577                                               else
   22578                                                 {
   22579                                                   /* 33222222222211111111110000000000
   22580                                                      10987654321098765432109876543210
   22581                                                      xx1011111xxxxxxx1001x0xxxxxxxxxx
   22582                                                      fmulx.  */
   22583                                                   return 127;
   22584                                                 }
   22585                                             }
   22586                                         }
   22587                                       else
   22588                                         {
   22589                                           if (((word >> 29) & 0x1) == 0)
   22590                                             {
   22591                                               /* 33222222222211111111110000000000
   22592                                                  10987654321098765432109876543210
   22593                                                  xx001111xxxxxxxx1101x0xxxxxxxxxx
   22594                                                  sqrdmulh.  */
   22595                                               return 112;
   22596                                             }
   22597                                           else
   22598                                             {
   22599                                               /* 33222222222211111111110000000000
   22600                                                  10987654321098765432109876543210
   22601                                                  xx101111xxxxxxxx1101x0xxxxxxxxxx
   22602                                                  sqrdmlah.  */
   22603                                               return 129;
   22604                                             }
   22605                                         }
   22606                                     }
   22607                                   else
   22608                                     {
   22609                                       if (((word >> 14) & 0x1) == 0)
   22610                                         {
   22611                                           if (((word >> 30) & 0x1) == 0)
   22612                                             {
   22613                                               /* 33222222222211111111110000000000
   22614                                                  10987654321098765432109876543210
   22615                                                  x0x01111xxxxxxxx1011x0xxxxxxxxxx
   22616                                                  sqdmull.  */
   22617                                               return 109;
   22618                                             }
   22619                                           else
   22620                                             {
   22621                                               /* 33222222222211111111110000000000
   22622                                                  10987654321098765432109876543210
   22623                                                  x1x01111xxxxxxxx1011x0xxxxxxxxxx
   22624                                                  sqdmull2.  */
   22625                                               return 110;
   22626                                             }
   22627                                         }
   22628                                       else
   22629                                         {
   22630                                           if (((word >> 29) & 0x1) == 0)
   22631                                             {
   22632                                               if (((word >> 22) & 0x1) == 0)
   22633                                                 {
   22634                                                   if (((word >> 23) & 0x1) == 0)
   22635                                                     {
   22636                                                       /* 33222222222211111111110000000000
   22637                                                          10987654321098765432109876543210
   22638                                                          xx00111100xxxxxx1111x0xxxxxxxxxx
   22639                                                          sudot.  */
   22640                                                       return 2421;
   22641                                                     }
   22642                                                   else
   22643                                                     {
   22644                                                       /* 33222222222211111111110000000000
   22645                                                          10987654321098765432109876543210
   22646                                                          xx00111110xxxxxx1111x0xxxxxxxxxx
   22647                                                          usdot.  */
   22648                                                       return 2420;
   22649                                                     }
   22650                                                 }
   22651                                               else
   22652                                                 {
   22653                                                   if (((word >> 23) & 0x1) == 0)
   22654                                                     {
   22655                                                       /* 33222222222211111111110000000000
   22656                                                          10987654321098765432109876543210
   22657                                                          xx00111101xxxxxx1111x0xxxxxxxxxx
   22658                                                          bfdot.  */
   22659                                                       return 2432;
   22660                                                     }
   22661                                                   else
   22662                                                     {
   22663                                                       if (((word >> 30) & 0x1) == 0)
   22664                                                         {
   22665                                                           /* 33222222222211111111110000000000
   22666                                                              10987654321098765432109876543210
   22667                                                              x000111111xxxxxx1111x0xxxxxxxxxx
   22668                                                              bfmlalb.  */
   22669                                                           return 2440;
   22670                                                         }
   22671                                                       else
   22672                                                         {
   22673                                                           /* 33222222222211111111110000000000
   22674                                                              10987654321098765432109876543210
   22675                                                              x100111111xxxxxx1111x0xxxxxxxxxx
   22676                                                              bfmlalt.  */
   22677                                                           return 2439;
   22678                                                         }
   22679                                                     }
   22680                                                 }
   22681                                             }
   22682                                           else
   22683                                             {
   22684                                               /* 33222222222211111111110000000000
   22685                                                  10987654321098765432109876543210
   22686                                                  xx101111xxxxxxxx1111x0xxxxxxxxxx
   22687                                                  sqrdmlsh.  */
   22688                                               return 130;
   22689                                             }
   22690                                         }
   22691                                     }
   22692                                 }
   22693                             }
   22694                           else
   22695                             {
   22696                               if (((word >> 11) & 0x1) == 0)
   22697                                 {
   22698                                   if (((word >> 14) & 0x1) == 0)
   22699                                     {
   22700                                       if (((word >> 12) & 0x1) == 0)
   22701                                         {
   22702                                           if (((word >> 29) & 0x1) == 0)
   22703                                             {
   22704                                               /* 33222222222211111111110000000000
   22705                                                  10987654321098765432109876543210
   22706                                                  xx001111xxxxxxxx10x001xxxxxxxxxx
   22707                                                  movi.  */
   22708                                               return 135;
   22709                                             }
   22710                                           else
   22711                                             {
   22712                                               /* 33222222222211111111110000000000
   22713                                                  10987654321098765432109876543210
   22714                                                  xx101111xxxxxxxx10x001xxxxxxxxxx
   22715                                                  mvni.  */
   22716                                               return 143;
   22717                                             }
   22718                                         }
   22719                                       else
   22720                                         {
   22721                                           if (((word >> 29) & 0x1) == 0)
   22722                                             {
   22723                                               /* 33222222222211111111110000000000
   22724                                                  10987654321098765432109876543210
   22725                                                  xx001111xxxxxxxx10x101xxxxxxxxxx
   22726                                                  orr.  */
   22727                                               return 136;
   22728                                             }
   22729                                           else
   22730                                             {
   22731                                               /* 33222222222211111111110000000000
   22732                                                  10987654321098765432109876543210
   22733                                                  xx101111xxxxxxxx10x101xxxxxxxxxx
   22734                                                  bic.  */
   22735                                               return 144;
   22736                                             }
   22737                                         }
   22738                                     }
   22739                                   else
   22740                                     {
   22741                                       if (((word >> 13) & 0x1) == 0)
   22742                                         {
   22743                                           if (((word >> 29) & 0x1) == 0)
   22744                                             {
   22745                                               /* 33222222222211111111110000000000
   22746                                                  10987654321098765432109876543210
   22747                                                  xx001111xxxxxxxx110x01xxxxxxxxxx
   22748                                                  movi.  */
   22749                                               return 137;
   22750                                             }
   22751                                           else
   22752                                             {
   22753                                               /* 33222222222211111111110000000000
   22754                                                  10987654321098765432109876543210
   22755                                                  xx101111xxxxxxxx110x01xxxxxxxxxx
   22756                                                  mvni.  */
   22757                                               return 145;
   22758                                             }
   22759                                         }
   22760                                       else
   22761                                         {
   22762                                           if (((word >> 12) & 0x1) == 0)
   22763                                             {
   22764                                               if (((word >> 29) & 0x1) == 0)
   22765                                                 {
   22766                                                   /* 33222222222211111111110000000000
   22767                                                      10987654321098765432109876543210
   22768                                                      xx001111xxxxxxxx111001xxxxxxxxxx
   22769                                                      movi.  */
   22770                                                   return 138;
   22771                                                 }
   22772                                               else
   22773                                                 {
   22774                                                   /* 33222222222211111111110000000000
   22775                                                      10987654321098765432109876543210
   22776                                                      xx101111xxxxxxxx111001xxxxxxxxxx
   22777                                                      movi.  */
   22778                                                   return 146;
   22779                                                 }
   22780                                             }
   22781                                           else
   22782                                             {
   22783                                               if (((word >> 29) & 0x1) == 0)
   22784                                                 {
   22785                                                   /* 33222222222211111111110000000000
   22786                                                      10987654321098765432109876543210
   22787                                                      xx001111xxxxxxxx111101xxxxxxxxxx
   22788                                                      fmov.  */
   22789                                                   return 139;
   22790                                                 }
   22791                                               else
   22792                                                 {
   22793                                                   /* 33222222222211111111110000000000
   22794                                                      10987654321098765432109876543210
   22795                                                      xx101111xxxxxxxx111101xxxxxxxxxx
   22796                                                      fmov.  */
   22797                                                   return 148;
   22798                                                 }
   22799                                             }
   22800                                         }
   22801                                     }
   22802                                 }
   22803                               else
   22804                                 {
   22805                                   if (((word >> 12) & 0x1) == 0)
   22806                                     {
   22807                                       if (((word >> 29) & 0x1) == 0)
   22808                                         {
   22809                                           if (((word >> 30) & 0x1) == 0)
   22810                                             {
   22811                                               /* 33222222222211111111110000000000
   22812                                                  10987654321098765432109876543210
   22813                                                  x0001111xxxxxxxx1xx011xxxxxxxxxx
   22814                                                  rshrn.  */
   22815                                               return 382;
   22816                                             }
   22817                                           else
   22818                                             {
   22819                                               /* 33222222222211111111110000000000
   22820                                                  10987654321098765432109876543210
   22821                                                  x1001111xxxxxxxx1xx011xxxxxxxxxx
   22822                                                  rshrn2.  */
   22823                                               return 383;
   22824                                             }
   22825                                         }
   22826                                       else
   22827                                         {
   22828                                           if (((word >> 30) & 0x1) == 0)
   22829                                             {
   22830                                               /* 33222222222211111111110000000000
   22831                                                  10987654321098765432109876543210
   22832                                                  x0101111xxxxxxxx1xx011xxxxxxxxxx
   22833                                                  sqrshrun.  */
   22834                                               return 406;
   22835                                             }
   22836                                           else
   22837                                             {
   22838                                               /* 33222222222211111111110000000000
   22839                                                  10987654321098765432109876543210
   22840                                                  x1101111xxxxxxxx1xx011xxxxxxxxxx
   22841                                                  sqrshrun2.  */
   22842                                               return 407;
   22843                                             }
   22844                                         }
   22845                                     }
   22846                                   else
   22847                                     {
   22848                                       if (((word >> 13) & 0x1) == 0)
   22849                                         {
   22850                                           if (((word >> 29) & 0x1) == 0)
   22851                                             {
   22852                                               if (((word >> 30) & 0x1) == 0)
   22853                                                 {
   22854                                                   /* 33222222222211111111110000000000
   22855                                                      10987654321098765432109876543210
   22856                                                      x0001111xxxxxxxx1x0111xxxxxxxxxx
   22857                                                      sqrshrn.  */
   22858                                                   return 386;
   22859                                                 }
   22860                                               else
   22861                                                 {
   22862                                                   /* 33222222222211111111110000000000
   22863                                                      10987654321098765432109876543210
   22864                                                      x1001111xxxxxxxx1x0111xxxxxxxxxx
   22865                                                      sqrshrn2.  */
   22866                                                   return 387;
   22867                                                 }
   22868                                             }
   22869                                           else
   22870                                             {
   22871                                               if (((word >> 30) & 0x1) == 0)
   22872                                                 {
   22873                                                   /* 33222222222211111111110000000000
   22874                                                      10987654321098765432109876543210
   22875                                                      x0101111xxxxxxxx1x0111xxxxxxxxxx
   22876                                                      uqrshrn.  */
   22877                                                   return 410;
   22878                                                 }
   22879                                               else
   22880                                                 {
   22881                                                   /* 33222222222211111111110000000000
   22882                                                      10987654321098765432109876543210
   22883                                                      x1101111xxxxxxxx1x0111xxxxxxxxxx
   22884                                                      uqrshrn2.  */
   22885                                                   return 411;
   22886                                                 }
   22887                                             }
   22888                                         }
   22889                                       else
   22890                                         {
   22891                                           if (((word >> 29) & 0x1) == 0)
   22892                                             {
   22893                                               /* 33222222222211111111110000000000
   22894                                                  10987654321098765432109876543210
   22895                                                  xx001111xxxxxxxx1x1111xxxxxxxxxx
   22896                                                  fmov.  */
   22897                                               return 140;
   22898                                             }
   22899                                           else
   22900                                             {
   22901                                               /* 33222222222211111111110000000000
   22902                                                  10987654321098765432109876543210
   22903                                                  xx101111xxxxxxxx1x1111xxxxxxxxxx
   22904                                                  fcvtzu.  */
   22905                                               return 418;
   22906                                             }
   22907                                         }
   22908                                     }
   22909                                 }
   22910                             }
   22911                         }
   22912                       else
   22913                         {
   22914                           if (((word >> 29) & 0x1) == 0)
   22915                             {
   22916                               if (((word >> 30) & 0x1) == 0)
   22917                                 {
   22918                                   if (((word >> 21) & 0x1) == 0)
   22919                                     {
   22920                                       /* 33222222222211111111110000000000
   22921                                          10987654321098765432109876543210
   22922                                          x0011111xx0xxxxx1xxxxxxxxxxxxxxx
   22923                                          fmsub.  */
   22924                                       return 860;
   22925                                     }
   22926                                   else
   22927                                     {
   22928                                       /* 33222222222211111111110000000000
   22929                                          10987654321098765432109876543210
   22930                                          x0011111xx1xxxxx1xxxxxxxxxxxxxxx
   22931                                          fnmsub.  */
   22932                                       return 864;
   22933                                     }
   22934                                 }
   22935                               else
   22936                                 {
   22937                                   if (((word >> 10) & 0x1) == 0)
   22938                                     {
   22939                                       if (((word >> 12) & 0x1) == 0)
   22940                                         {
   22941                                           /* 33222222222211111111110000000000
   22942                                              10987654321098765432109876543210
   22943                                              x1011111xxxxxxxx1xx0x0xxxxxxxxxx
   22944                                              sqdmulh.  */
   22945                                           return 428;
   22946                                         }
   22947                                       else
   22948                                         {
   22949                                           if (((word >> 13) & 0x1) == 0)
   22950                                             {
   22951                                               if (((word >> 14) & 0x1) == 0)
   22952                                                 {
   22953                                                   if (((word >> 23) & 0x1) == 0)
   22954                                                     {
   22955                                                       /* 33222222222211111111110000000000
   22956                                                          10987654321098765432109876543210
   22957                                                          x10111110xxxxxxx1001x0xxxxxxxxxx
   22958                                                          fmul.  */
   22959                                                       return 435;
   22960                                                     }
   22961                                                   else
   22962                                                     {
   22963                                                       /* 33222222222211111111110000000000
   22964                                                          10987654321098765432109876543210
   22965                                                          x10111111xxxxxxx1001x0xxxxxxxxxx
   22966                                                          fmul.  */
   22967                                                       return 434;
   22968                                                     }
   22969                                                 }
   22970                                               else
   22971                                                 {
   22972                                                   /* 33222222222211111111110000000000
   22973                                                      10987654321098765432109876543210
   22974                                                      x1011111xxxxxxxx1101x0xxxxxxxxxx
   22975                                                      sqrdmulh.  */
   22976                                                   return 429;
   22977                                                 }
   22978                                             }
   22979                                           else
   22980                                             {
   22981                                               /* 33222222222211111111110000000000
   22982                                                  10987654321098765432109876543210
   22983                                                  x1011111xxxxxxxx1x11x0xxxxxxxxxx
   22984                                                  sqdmull.  */
   22985                                               return 427;
   22986                                             }
   22987                                         }
   22988                                     }
   22989                                   else
   22990                                     {
   22991                                       if (((word >> 11) & 0x1) == 0)
   22992                                         {
   22993                                           if (((word >> 12) & 0x1) == 0)
   22994                                             {
   22995                                               /* 33222222222211111111110000000000
   22996                                                  10987654321098765432109876543210
   22997                                                  x1011111xxxxxxxx1xx001xxxxxxxxxx
   22998                                                  scvtf.  */
   22999                                               return 598;
   23000                                             }
   23001                                           else
   23002                                             {
   23003                                               /* 33222222222211111111110000000000
   23004                                                  10987654321098765432109876543210
   23005                                                  x1011111xxxxxxxx1xx101xxxxxxxxxx
   23006                                                  sqshrn.  */
   23007                                               return 596;
   23008                                             }
   23009                                         }
   23010                                       else
   23011                                         {
   23012                                           if (((word >> 13) & 0x1) == 0)
   23013                                             {
   23014                                               /* 33222222222211111111110000000000
   23015                                                  10987654321098765432109876543210
   23016                                                  x1011111xxxxxxxx1x0x11xxxxxxxxxx
   23017                                                  sqrshrn.  */
   23018                                               return 597;
   23019                                             }
   23020                                           else
   23021                                             {
   23022                                               /* 33222222222211111111110000000000
   23023                                                  10987654321098765432109876543210
   23024                                                  x1011111xxxxxxxx1x1x11xxxxxxxxxx
   23025                                                  fcvtzs.  */
   23026                                               return 600;
   23027                                             }
   23028                                         }
   23029                                     }
   23030                                 }
   23031                             }
   23032                           else
   23033                             {
   23034                               if (((word >> 10) & 0x1) == 0)
   23035                                 {
   23036                                   if (((word >> 13) & 0x1) == 0)
   23037                                     {
   23038                                       if (((word >> 14) & 0x1) == 0)
   23039                                         {
   23040                                           if (((word >> 23) & 0x1) == 0)
   23041                                             {
   23042                                               /* 33222222222211111111110000000000
   23043                                                  10987654321098765432109876543210
   23044                                                  xx1111110xxxxxxx100xx0xxxxxxxxxx
   23045                                                  fmulx.  */
   23046                                               return 437;
   23047                                             }
   23048                                           else
   23049                                             {
   23050                                               /* 33222222222211111111110000000000
   23051                                                  10987654321098765432109876543210
   23052                                                  xx1111111xxxxxxx100xx0xxxxxxxxxx
   23053                                                  fmulx.  */
   23054                                               return 436;
   23055                                             }
   23056                                         }
   23057                                       else
   23058                                         {
   23059                                           /* 33222222222211111111110000000000
   23060                                              10987654321098765432109876543210
   23061                                              xx111111xxxxxxxx110xx0xxxxxxxxxx
   23062                                              sqrdmlah.  */
   23063                                           return 438;
   23064                                         }
   23065                                     }
   23066                                   else
   23067                                     {
   23068                                       /* 33222222222211111111110000000000
   23069                                          10987654321098765432109876543210
   23070                                          xx111111xxxxxxxx1x1xx0xxxxxxxxxx
   23071                                          sqrdmlsh.  */
   23072                                       return 439;
   23073                                     }
   23074                                 }
   23075                               else
   23076                                 {
   23077                                   if (((word >> 11) & 0x1) == 0)
   23078                                     {
   23079                                       if (((word >> 12) & 0x1) == 0)
   23080                                         {
   23081                                           if (((word >> 13) & 0x1) == 0)
   23082                                             {
   23083                                               /* 33222222222211111111110000000000
   23084                                                  10987654321098765432109876543210
   23085                                                  xx111111xxxxxxxx1x0001xxxxxxxxxx
   23086                                                  sqshrun.  */
   23087                                               return 610;
   23088                                             }
   23089                                           else
   23090                                             {
   23091                                               /* 33222222222211111111110000000000
   23092                                                  10987654321098765432109876543210
   23093                                                  xx111111xxxxxxxx1x1001xxxxxxxxxx
   23094                                                  ucvtf.  */
   23095                                               return 614;
   23096                                             }
   23097                                         }
   23098                                       else
   23099                                         {
   23100                                           /* 33222222222211111111110000000000
   23101                                              10987654321098765432109876543210
   23102                                              xx111111xxxxxxxx1xx101xxxxxxxxxx
   23103                                              uqshrn.  */
   23104                                           return 612;
   23105                                         }
   23106                                     }
   23107                                   else
   23108                                     {
   23109                                       if (((word >> 12) & 0x1) == 0)
   23110                                         {
   23111                                           /* 33222222222211111111110000000000
   23112                                              10987654321098765432109876543210
   23113                                              xx111111xxxxxxxx1xx011xxxxxxxxxx
   23114                                              sqrshrun.  */
   23115                                           return 611;
   23116                                         }
   23117                                       else
   23118                                         {
   23119                                           if (((word >> 13) & 0x1) == 0)
   23120                                             {
   23121                                               /* 33222222222211111111110000000000
   23122                                                  10987654321098765432109876543210
   23123                                                  xx111111xxxxxxxx1x0111xxxxxxxxxx
   23124                                                  uqrshrn.  */
   23125                                               return 613;
   23126                                             }
   23127                                           else
   23128                                             {
   23129                                               /* 33222222222211111111110000000000
   23130                                                  10987654321098765432109876543210
   23131                                                  xx111111xxxxxxxx1x1111xxxxxxxxxx
   23132                                                  fcvtzu.  */
   23133                                               return 616;
   23134                                             }
   23135                                         }
   23136                                     }
   23137                                 }
   23138                             }
   23139                         }
   23140                     }
   23141                 }
   23142             }
   23143         }
   23144     }
   23145 }
   23146 
   23147 /* Lookup opcode WORD in the opcode table.  N.B. all alias
   23148    opcodes are ignored here.  */
   23149 
   23150 const aarch64_opcode *
   23151 aarch64_opcode_lookup (uint32_t word)
   23152 {
   23153   return aarch64_opcode_table + aarch64_opcode_lookup_1 (word);
   23154 }
   23155 
   23156 const aarch64_opcode *
   23157 aarch64_find_next_opcode (const aarch64_opcode *opcode)
   23158 {
   23159   /* Use the index as the key to locate the next opcode.  */
   23160   int key = opcode - aarch64_opcode_table;
   23161   int value;
   23162   switch (key)
   23163     {
   23164     case 12: value = 19; break;	/* add --> addg.  */
   23165     case 19: return NULL;		/* addg --> NULL.  */
   23166     case 16: value = 20; break;	/* sub --> subg.  */
   23167     case 20: return NULL;		/* subg --> NULL.  */
   23168     case 971: value = 975; break;	/* stnp --> stp.  */
   23169     case 975: return NULL;		/* stp --> NULL.  */
   23170     case 969: value = 970; break;	/* stllrb --> stllrh.  */
   23171     case 970: return NULL;		/* stllrh --> NULL.  */
   23172     case 972: value = 976; break;	/* ldnp --> ldp.  */
   23173     case 976: return NULL;		/* ldp --> NULL.  */
   23174     case 1629: value = 1630; break;	/* ldff1b --> ldff1b.  */
   23175     case 1630: return NULL;		/* ldff1b --> NULL.  */
   23176     case 1685: value = 1686; break;	/* ldff1sw --> ldff1sw.  */
   23177     case 1686: return NULL;		/* ldff1sw --> NULL.  */
   23178     case 1633: value = 1634; break;	/* ldff1b --> ldff1b.  */
   23179     case 1634: return NULL;		/* ldff1b --> NULL.  */
   23180     case 1652: value = 1653; break;	/* ldff1h --> ldff1h.  */
   23181     case 1653: return NULL;		/* ldff1h --> NULL.  */
   23182     case 1631: value = 1632; break;	/* ldff1b --> ldff1b.  */
   23183     case 1632: return NULL;		/* ldff1b --> NULL.  */
   23184     case 1650: value = 1651; break;	/* ldff1h --> ldff1h.  */
   23185     case 1651: return NULL;		/* ldff1h --> NULL.  */
   23186     case 1635: value = 1636; break;	/* ldff1b --> ldff1b.  */
   23187     case 1636: return NULL;		/* ldff1b --> NULL.  */
   23188     case 1654: value = 1655; break;	/* ldff1h --> ldff1h.  */
   23189     case 1655: return NULL;		/* ldff1h --> NULL.  */
   23190     case 1675: value = 1676; break;	/* ldff1sh --> ldff1sh.  */
   23191     case 1676: return NULL;		/* ldff1sh --> NULL.  */
   23192     case 1663: value = 1664; break;	/* ldff1sb --> ldff1sb.  */
   23193     case 1664: return NULL;		/* ldff1sb --> NULL.  */
   23194     case 1694: value = 1695; break;	/* ldff1w --> ldff1w.  */
   23195     case 1695: return NULL;		/* ldff1w --> NULL.  */
   23196     case 1667: value = 1668; break;	/* ldff1sb --> ldff1sb.  */
   23197     case 1668: return NULL;		/* ldff1sb --> NULL.  */
   23198     case 1677: value = 1678; break;	/* ldff1sh --> ldff1sh.  */
   23199     case 1678: return NULL;		/* ldff1sh --> NULL.  */
   23200     case 1665: value = 1666; break;	/* ldff1sb --> ldff1sb.  */
   23201     case 1666: return NULL;		/* ldff1sb --> NULL.  */
   23202     case 1696: value = 1697; break;	/* ldff1w --> ldff1w.  */
   23203     case 1697: return NULL;		/* ldff1w --> NULL.  */
   23204     case 1641: value = 1642; break;	/* ldff1d --> ldff1d.  */
   23205     case 1642: return NULL;		/* ldff1d --> NULL.  */
   23206     case 811: value = 812; break;	/* xaflag --> axflag.  */
   23207     case 812: value = 1190; break;	/* axflag --> tcommit.  */
   23208     case 1190: value = 1193; break;	/* tcommit --> msr.  */
   23209     case 1193: value = 1194; break;	/* msr --> hint.  */
   23210     case 1194: value = 1203; break;	/* hint --> dgh.  */
   23211     case 1203: value = 1212; break;	/* dgh --> clrex.  */
   23212     case 1212: value = 1213; break;	/* clrex --> dsb.  */
   23213     case 1213: value = 1217; break;	/* dsb --> dmb.  */
   23214     case 1217: value = 1218; break;	/* dmb --> isb.  */
   23215     case 1218: value = 1219; break;	/* isb --> sb.  */
   23216     case 1219: value = 1220; break;	/* sb --> sys.  */
   23217     case 1220: value = 1228; break;	/* sys --> cfinv.  */
   23218     case 1228: value = 1229; break;	/* cfinv --> msr.  */
   23219     case 1229: return NULL;		/* msr --> NULL.  */
   23220     case 1189: value = 1191; break;	/* tstart --> ttest.  */
   23221     case 1191: value = 1230; break;	/* ttest --> sysl.  */
   23222     case 1230: value = 1231; break;	/* sysl --> mrs.  */
   23223     case 1231: return NULL;		/* mrs --> NULL.  */
   23224     case 440: value = 441; break;	/* st4 --> st1.  */
   23225     case 441: value = 442; break;	/* st1 --> st2.  */
   23226     case 442: value = 443; break;	/* st2 --> st3.  */
   23227     case 443: return NULL;		/* st3 --> NULL.  */
   23228     case 448: value = 449; break;	/* st4 --> st1.  */
   23229     case 449: value = 450; break;	/* st1 --> st2.  */
   23230     case 450: value = 451; break;	/* st2 --> st3.  */
   23231     case 451: return NULL;		/* st3 --> NULL.  */
   23232     case 444: value = 445; break;	/* ld4 --> ld1.  */
   23233     case 445: value = 446; break;	/* ld1 --> ld2.  */
   23234     case 446: value = 447; break;	/* ld2 --> ld3.  */
   23235     case 447: return NULL;		/* ld3 --> NULL.  */
   23236     case 460: value = 462; break;	/* ld1 --> ld1r.  */
   23237     case 462: return NULL;		/* ld1r --> NULL.  */
   23238     case 464: value = 466; break;	/* ld2 --> ld2r.  */
   23239     case 466: return NULL;		/* ld2r --> NULL.  */
   23240     case 461: value = 463; break;	/* ld3 --> ld3r.  */
   23241     case 463: return NULL;		/* ld3r --> NULL.  */
   23242     case 465: value = 467; break;	/* ld4 --> ld4r.  */
   23243     case 467: return NULL;		/* ld4r --> NULL.  */
   23244     case 452: value = 453; break;	/* ld4 --> ld1.  */
   23245     case 453: value = 454; break;	/* ld1 --> ld2.  */
   23246     case 454: value = 455; break;	/* ld2 --> ld3.  */
   23247     case 455: return NULL;		/* ld3 --> NULL.  */
   23248     case 472: value = 474; break;	/* ld1 --> ld1r.  */
   23249     case 474: return NULL;		/* ld1r --> NULL.  */
   23250     case 473: value = 475; break;	/* ld3 --> ld3r.  */
   23251     case 475: return NULL;		/* ld3r --> NULL.  */
   23252     case 476: value = 478; break;	/* ld2 --> ld2r.  */
   23253     case 478: return NULL;		/* ld2r --> NULL.  */
   23254     case 477: value = 479; break;	/* ld4 --> ld4r.  */
   23255     case 479: return NULL;		/* ld4r --> NULL.  */
   23256     case 764: value = 765; break;	/* fcvtzs --> fcvtzs.  */
   23257     case 765: return NULL;		/* fcvtzs --> NULL.  */
   23258     case 760: value = 761; break;	/* scvtf --> scvtf.  */
   23259     case 761: return NULL;		/* scvtf --> NULL.  */
   23260     case 766: value = 767; break;	/* fcvtzu --> fcvtzu.  */
   23261     case 767: return NULL;		/* fcvtzu --> NULL.  */
   23262     case 762: value = 763; break;	/* ucvtf --> ucvtf.  */
   23263     case 763: return NULL;		/* ucvtf --> NULL.  */
   23264     case 768: value = 769; break;	/* fcvtns --> fcvtns.  */
   23265     case 769: return NULL;		/* fcvtns --> NULL.  */
   23266     case 788: value = 789; break;	/* fcvtms --> fcvtms.  */
   23267     case 789: return NULL;		/* fcvtms --> NULL.  */
   23268     case 784: value = 785; break;	/* fcvtps --> fcvtps.  */
   23269     case 785: return NULL;		/* fcvtps --> NULL.  */
   23270     case 792: value = 793; break;	/* fcvtzs --> fcvtzs.  */
   23271     case 793: return NULL;		/* fcvtzs --> NULL.  */
   23272     case 776: value = 777; break;	/* fcvtas --> fcvtas.  */
   23273     case 777: return NULL;		/* fcvtas --> NULL.  */
   23274     case 772: value = 773; break;	/* scvtf --> scvtf.  */
   23275     case 773: return NULL;		/* scvtf --> NULL.  */
   23276     case 780: value = 781; break;	/* fmov --> fmov.  */
   23277     case 781: return NULL;		/* fmov --> NULL.  */
   23278     case 770: value = 771; break;	/* fcvtnu --> fcvtnu.  */
   23279     case 771: return NULL;		/* fcvtnu --> NULL.  */
   23280     case 790: value = 791; break;	/* fcvtmu --> fcvtmu.  */
   23281     case 791: return NULL;		/* fcvtmu --> NULL.  */
   23282     case 786: value = 787; break;	/* fcvtpu --> fcvtpu.  */
   23283     case 787: return NULL;		/* fcvtpu --> NULL.  */
   23284     case 794: value = 795; break;	/* fcvtzu --> fcvtzu.  */
   23285     case 795: return NULL;		/* fcvtzu --> NULL.  */
   23286     case 778: value = 779; break;	/* fcvtau --> fcvtau.  */
   23287     case 779: return NULL;		/* fcvtau --> NULL.  */
   23288     case 774: value = 775; break;	/* ucvtf --> ucvtf.  */
   23289     case 775: return NULL;		/* ucvtf --> NULL.  */
   23290     case 782: value = 783; break;	/* fmov --> fmov.  */
   23291     case 783: return NULL;		/* fmov --> NULL.  */
   23292     case 817: value = 818; break;	/* fmov --> fmov.  */
   23293     case 818: return NULL;		/* fmov --> NULL.  */
   23294     case 826: value = 827; break;	/* frintn --> frintn.  */
   23295     case 827: return NULL;		/* frintn --> NULL.  */
   23296     case 821: value = 822; break;	/* fneg --> fneg.  */
   23297     case 822: return NULL;		/* fneg --> NULL.  */
   23298     case 830: value = 831; break;	/* frintm --> frintm.  */
   23299     case 831: return NULL;		/* frintm --> NULL.  */
   23300     case 819: value = 820; break;	/* fabs --> fabs.  */
   23301     case 820: return NULL;		/* fabs --> NULL.  */
   23302     case 828: value = 829; break;	/* frintp --> frintp.  */
   23303     case 829: return NULL;		/* frintp --> NULL.  */
   23304     case 823: value = 824; break;	/* fsqrt --> fsqrt.  */
   23305     case 824: return NULL;		/* fsqrt --> NULL.  */
   23306     case 832: value = 833; break;	/* frintz --> frintz.  */
   23307     case 833: return NULL;		/* frintz --> NULL.  */
   23308     case 825: value = 2436; break;	/* fcvt --> bfcvt.  */
   23309     case 2436: return NULL;		/* bfcvt --> NULL.  */
   23310     case 834: value = 835; break;	/* frinta --> frinta.  */
   23311     case 835: return NULL;		/* frinta --> NULL.  */
   23312     case 836: value = 837; break;	/* frintx --> frintx.  */
   23313     case 837: return NULL;		/* frintx --> NULL.  */
   23314     case 838: value = 839; break;	/* frinti --> frinti.  */
   23315     case 839: return NULL;		/* frinti --> NULL.  */
   23316     case 803: value = 804; break;	/* fcmp --> fcmp.  */
   23317     case 804: return NULL;		/* fcmp --> NULL.  */
   23318     case 805: value = 806; break;	/* fcmpe --> fcmpe.  */
   23319     case 806: return NULL;		/* fcmpe --> NULL.  */
   23320     case 807: value = 808; break;	/* fcmp --> fcmp.  */
   23321     case 808: return NULL;		/* fcmp --> NULL.  */
   23322     case 809: value = 810; break;	/* fcmpe --> fcmpe.  */
   23323     case 810: return NULL;		/* fcmpe --> NULL.  */
   23324     case 866: value = 867; break;	/* fmov --> fmov.  */
   23325     case 867: return NULL;		/* fmov --> NULL.  */
   23326     case 840: value = 841; break;	/* fmul --> fmul.  */
   23327     case 841: return NULL;		/* fmul --> NULL.  */
   23328     case 856: value = 857; break;	/* fnmul --> fnmul.  */
   23329     case 857: return NULL;		/* fnmul --> NULL.  */
   23330     case 848: value = 849; break;	/* fmax --> fmax.  */
   23331     case 849: return NULL;		/* fmax --> NULL.  */
   23332     case 844: value = 845; break;	/* fadd --> fadd.  */
   23333     case 845: return NULL;		/* fadd --> NULL.  */
   23334     case 852: value = 853; break;	/* fmaxnm --> fmaxnm.  */
   23335     case 853: return NULL;		/* fmaxnm --> NULL.  */
   23336     case 842: value = 843; break;	/* fdiv --> fdiv.  */
   23337     case 843: return NULL;		/* fdiv --> NULL.  */
   23338     case 850: value = 851; break;	/* fmin --> fmin.  */
   23339     case 851: return NULL;		/* fmin --> NULL.  */
   23340     case 846: value = 847; break;	/* fsub --> fsub.  */
   23341     case 847: return NULL;		/* fsub --> NULL.  */
   23342     case 854: value = 855; break;	/* fminnm --> fminnm.  */
   23343     case 855: return NULL;		/* fminnm --> NULL.  */
   23344     case 799: value = 800; break;	/* fccmp --> fccmp.  */
   23345     case 800: return NULL;		/* fccmp --> NULL.  */
   23346     case 801: value = 802; break;	/* fccmpe --> fccmpe.  */
   23347     case 802: return NULL;		/* fccmpe --> NULL.  */
   23348     case 868: value = 869; break;	/* fcsel --> fcsel.  */
   23349     case 869: return NULL;		/* fcsel --> NULL.  */
   23350     case 133: value = 374; break;	/* movi --> sshr.  */
   23351     case 374: value = 376; break;	/* sshr --> srshr.  */
   23352     case 376: return NULL;		/* srshr --> NULL.  */
   23353     case 141: value = 396; break;	/* mvni --> ushr.  */
   23354     case 396: value = 398; break;	/* ushr --> urshr.  */
   23355     case 398: value = 400; break;	/* urshr --> sri.  */
   23356     case 400: value = 402; break;	/* sri --> sqshlu.  */
   23357     case 402: return NULL;		/* sqshlu --> NULL.  */
   23358     case 134: value = 375; break;	/* orr --> ssra.  */
   23359     case 375: value = 377; break;	/* ssra --> srsra.  */
   23360     case 377: value = 378; break;	/* srsra --> shl.  */
   23361     case 378: value = 379; break;	/* shl --> sqshl.  */
   23362     case 379: return NULL;		/* sqshl --> NULL.  */
   23363     case 142: value = 397; break;	/* bic --> usra.  */
   23364     case 397: value = 399; break;	/* usra --> ursra.  */
   23365     case 399: value = 401; break;	/* ursra --> sli.  */
   23366     case 401: value = 403; break;	/* sli --> uqshl.  */
   23367     case 403: return NULL;		/* uqshl --> NULL.  */
   23368     case 858: value = 859; break;	/* fmadd --> fmadd.  */
   23369     case 859: return NULL;		/* fmadd --> NULL.  */
   23370     case 862: value = 863; break;	/* fnmadd --> fnmadd.  */
   23371     case 863: return NULL;		/* fnmadd --> NULL.  */
   23372     case 135: value = 380; break;	/* movi --> shrn.  */
   23373     case 380: value = 381; break;	/* shrn --> shrn2.  */
   23374     case 381: value = 388; break;	/* shrn2 --> sshll.  */
   23375     case 388: value = 390; break;	/* sshll --> sshll2.  */
   23376     case 390: return NULL;		/* sshll2 --> NULL.  */
   23377     case 143: value = 404; break;	/* mvni --> sqshrun.  */
   23378     case 404: value = 405; break;	/* sqshrun --> sqshrun2.  */
   23379     case 405: value = 412; break;	/* sqshrun2 --> ushll.  */
   23380     case 412: value = 414; break;	/* ushll --> ushll2.  */
   23381     case 414: return NULL;		/* ushll2 --> NULL.  */
   23382     case 136: value = 384; break;	/* orr --> sqshrn.  */
   23383     case 384: value = 385; break;	/* sqshrn --> sqshrn2.  */
   23384     case 385: return NULL;		/* sqshrn2 --> NULL.  */
   23385     case 144: value = 408; break;	/* bic --> uqshrn.  */
   23386     case 408: value = 409; break;	/* uqshrn --> uqshrn2.  */
   23387     case 409: return NULL;		/* uqshrn2 --> NULL.  */
   23388     case 138: value = 392; break;	/* movi --> scvtf.  */
   23389     case 392: value = 393; break;	/* scvtf --> scvtf.  */
   23390     case 393: return NULL;		/* scvtf --> NULL.  */
   23391     case 146: value = 147; break;	/* movi --> movi.  */
   23392     case 147: value = 416; break;	/* movi --> ucvtf.  */
   23393     case 416: value = 417; break;	/* ucvtf --> ucvtf.  */
   23394     case 417: return NULL;		/* ucvtf --> NULL.  */
   23395     case 140: value = 394; break;	/* fmov --> fcvtzs.  */
   23396     case 394: value = 395; break;	/* fcvtzs --> fcvtzs.  */
   23397     case 395: return NULL;		/* fcvtzs --> NULL.  */
   23398     case 418: value = 419; break;	/* fcvtzu --> fcvtzu.  */
   23399     case 419: return NULL;		/* fcvtzu --> NULL.  */
   23400     case 860: value = 861; break;	/* fmsub --> fmsub.  */
   23401     case 861: return NULL;		/* fmsub --> NULL.  */
   23402     case 864: value = 865; break;	/* fnmsub --> fnmsub.  */
   23403     case 865: return NULL;		/* fnmsub --> NULL.  */
   23404     case 598: value = 599; break;	/* scvtf --> scvtf.  */
   23405     case 599: return NULL;		/* scvtf --> NULL.  */
   23406     case 600: value = 601; break;	/* fcvtzs --> fcvtzs.  */
   23407     case 601: return NULL;		/* fcvtzs --> NULL.  */
   23408     case 614: value = 615; break;	/* ucvtf --> ucvtf.  */
   23409     case 615: return NULL;		/* ucvtf --> NULL.  */
   23410     case 616: value = 617; break;	/* fcvtzu --> fcvtzu.  */
   23411     case 617: return NULL;		/* fcvtzu --> NULL.  */
   23412     default: return NULL;
   23413     }
   23414 
   23415   return aarch64_opcode_table + value;
   23416 }
   23417 
   23418 const aarch64_opcode *
   23419 aarch64_find_alias_opcode (const aarch64_opcode *opcode)
   23420 {
   23421   /* Use the index as the key to locate the alias opcode.  */
   23422   int key = opcode - aarch64_opcode_table;
   23423   int value;
   23424   switch (key)
   23425     {
   23426     case 2: value = 3; break;	/* sbc --> ngc.  */
   23427     case 4: value = 5; break;	/* sbcs --> ngcs.  */
   23428     case 7: value = 8; break;	/* adds --> cmn.  */
   23429     case 10: value = 11; break;	/* subs --> cmp.  */
   23430     case 12: value = 13; break;	/* add --> mov.  */
   23431     case 14: value = 15; break;	/* adds --> cmn.  */
   23432     case 17: value = 18; break;	/* subs --> cmp.  */
   23433     case 22: value = 23; break;	/* adds --> cmn.  */
   23434     case 24: value = 25; break;	/* sub --> neg.  */
   23435     case 26: value = 27; break;	/* subs --> cmp.  */
   23436     case 152: value = 153; break;	/* umov --> mov.  */
   23437     case 154: value = 155; break;	/* ins --> mov.  */
   23438     case 156: value = 157; break;	/* ins --> mov.  */
   23439     case 242: value = 243; break;	/* not --> mvn.  */
   23440     case 317: value = 318; break;	/* orr --> mov.  */
   23441     case 388: value = 389; break;	/* sshll --> sxtl.  */
   23442     case 390: value = 391; break;	/* sshll2 --> sxtl2.  */
   23443     case 412: value = 413; break;	/* ushll --> uxtl.  */
   23444     case 414: value = 415; break;	/* ushll2 --> uxtl2.  */
   23445     case 535: value = 536; break;	/* dup --> mov.  */
   23446     case 618: value = 623; break;	/* sbfm --> sxtw.  */
   23447     case 625: value = 627; break;	/* bfm --> bfc.  */
   23448     case 629: value = 633; break;	/* ubfm --> uxth.  */
   23449     case 663: value = 665; break;	/* csinc --> cset.  */
   23450     case 666: value = 668; break;	/* csinv --> csetm.  */
   23451     case 669: value = 670; break;	/* csneg --> cneg.  */
   23452     case 688: value = 688; break;	/* rev --> rev.  */
   23453     case 713: value = 714; break;	/* lslv --> lsl.  */
   23454     case 715: value = 716; break;	/* lsrv --> lsr.  */
   23455     case 717: value = 718; break;	/* asrv --> asr.  */
   23456     case 719: value = 720; break;	/* rorv --> ror.  */
   23457     case 722: value = 723; break;	/* subps --> cmpp.  */
   23458     case 735: value = 736; break;	/* madd --> mul.  */
   23459     case 737: value = 738; break;	/* msub --> mneg.  */
   23460     case 739: value = 740; break;	/* smaddl --> smull.  */
   23461     case 741: value = 742; break;	/* smsubl --> smnegl.  */
   23462     case 744: value = 745; break;	/* umaddl --> umull.  */
   23463     case 746: value = 747; break;	/* umsubl --> umnegl.  */
   23464     case 758: value = 759; break;	/* extr --> ror.  */
   23465     case 991: value = 992; break;	/* and --> bic.  */
   23466     case 993: value = 994; break;	/* orr --> mov.  */
   23467     case 996: value = 997; break;	/* ands --> tst.  */
   23468     case 1000: value = 1002; break;	/* orr --> uxtw.  */
   23469     case 1003: value = 1004; break;	/* orn --> mvn.  */
   23470     case 1007: value = 1008; break;	/* ands --> tst.  */
   23471     case 1038: value = 1134; break;	/* ldaddb --> staddb.  */
   23472     case 1039: value = 1135; break;	/* ldaddh --> staddh.  */
   23473     case 1040: value = 1136; break;	/* ldadd --> stadd.  */
   23474     case 1042: value = 1137; break;	/* ldaddlb --> staddlb.  */
   23475     case 1045: value = 1138; break;	/* ldaddlh --> staddlh.  */
   23476     case 1048: value = 1139; break;	/* ldaddl --> staddl.  */
   23477     case 1050: value = 1140; break;	/* ldclrb --> stclrb.  */
   23478     case 1051: value = 1141; break;	/* ldclrh --> stclrh.  */
   23479     case 1052: value = 1142; break;	/* ldclr --> stclr.  */
   23480     case 1054: value = 1143; break;	/* ldclrlb --> stclrlb.  */
   23481     case 1057: value = 1144; break;	/* ldclrlh --> stclrlh.  */
   23482     case 1060: value = 1145; break;	/* ldclrl --> stclrl.  */
   23483     case 1062: value = 1146; break;	/* ldeorb --> steorb.  */
   23484     case 1063: value = 1147; break;	/* ldeorh --> steorh.  */
   23485     case 1064: value = 1148; break;	/* ldeor --> steor.  */
   23486     case 1066: value = 1149; break;	/* ldeorlb --> steorlb.  */
   23487     case 1069: value = 1150; break;	/* ldeorlh --> steorlh.  */
   23488     case 1072: value = 1151; break;	/* ldeorl --> steorl.  */
   23489     case 1074: value = 1152; break;	/* ldsetb --> stsetb.  */
   23490     case 1075: value = 1153; break;	/* ldseth --> stseth.  */
   23491     case 1076: value = 1154; break;	/* ldset --> stset.  */
   23492     case 1078: value = 1155; break;	/* ldsetlb --> stsetlb.  */
   23493     case 1081: value = 1156; break;	/* ldsetlh --> stsetlh.  */
   23494     case 1084: value = 1157; break;	/* ldsetl --> stsetl.  */
   23495     case 1086: value = 1158; break;	/* ldsmaxb --> stsmaxb.  */
   23496     case 1087: value = 1159; break;	/* ldsmaxh --> stsmaxh.  */
   23497     case 1088: value = 1160; break;	/* ldsmax --> stsmax.  */
   23498     case 1090: value = 1161; break;	/* ldsmaxlb --> stsmaxlb.  */
   23499     case 1093: value = 1162; break;	/* ldsmaxlh --> stsmaxlh.  */
   23500     case 1096: value = 1163; break;	/* ldsmaxl --> stsmaxl.  */
   23501     case 1098: value = 1164; break;	/* ldsminb --> stsminb.  */
   23502     case 1099: value = 1165; break;	/* ldsminh --> stsminh.  */
   23503     case 1100: value = 1166; break;	/* ldsmin --> stsmin.  */
   23504     case 1102: value = 1167; break;	/* ldsminlb --> stsminlb.  */
   23505     case 1105: value = 1168; break;	/* ldsminlh --> stsminlh.  */
   23506     case 1108: value = 1169; break;	/* ldsminl --> stsminl.  */
   23507     case 1110: value = 1170; break;	/* ldumaxb --> stumaxb.  */
   23508     case 1111: value = 1171; break;	/* ldumaxh --> stumaxh.  */
   23509     case 1112: value = 1172; break;	/* ldumax --> stumax.  */
   23510     case 1114: value = 1173; break;	/* ldumaxlb --> stumaxlb.  */
   23511     case 1117: value = 1174; break;	/* ldumaxlh --> stumaxlh.  */
   23512     case 1120: value = 1175; break;	/* ldumaxl --> stumaxl.  */
   23513     case 1122: value = 1176; break;	/* lduminb --> stuminb.  */
   23514     case 1123: value = 1177; break;	/* lduminh --> stuminh.  */
   23515     case 1124: value = 1178; break;	/* ldumin --> stumin.  */
   23516     case 1126: value = 1179; break;	/* lduminlb --> stuminlb.  */
   23517     case 1129: value = 1180; break;	/* lduminlh --> stuminlh.  */
   23518     case 1132: value = 1181; break;	/* lduminl --> stuminl.  */
   23519     case 1182: value = 1183; break;	/* movn --> mov.  */
   23520     case 1184: value = 1185; break;	/* movz --> mov.  */
   23521     case 1194: value = 1239; break;	/* hint --> autibsp.  */
   23522     case 1213: value = 1216; break;	/* dsb --> pssbb.  */
   23523     case 1220: value = 1227; break;	/* sys --> cpp.  */
   23524     case 1287: value = 2037; break;	/* and --> bic.  */
   23525     case 1289: value = 1270; break;	/* and --> mov.  */
   23526     case 1290: value = 1274; break;	/* ands --> movs.  */
   23527     case 1325: value = 2038; break;	/* cmpge --> cmple.  */
   23528     case 1328: value = 2041; break;	/* cmpgt --> cmplt.  */
   23529     case 1330: value = 2039; break;	/* cmphi --> cmplo.  */
   23530     case 1333: value = 2040; break;	/* cmphs --> cmpls.  */
   23531     case 1355: value = 1267; break;	/* cpy --> mov.  */
   23532     case 1356: value = 1269; break;	/* cpy --> mov.  */
   23533     case 1357: value = 2048; break;	/* cpy --> fmov.  */
   23534     case 1369: value = 1262; break;	/* dup --> mov.  */
   23535     case 1370: value = 1264; break;	/* dup --> mov.  */
   23536     case 1371: value = 2047; break;	/* dup --> fmov.  */
   23537     case 1372: value = 1265; break;	/* dupm --> mov.  */
   23538     case 1374: value = 2042; break;	/* eor --> eon.  */
   23539     case 1376: value = 1275; break;	/* eor --> not.  */
   23540     case 1377: value = 1276; break;	/* eors --> nots.  */
   23541     case 1382: value = 2043; break;	/* facge --> facle.  */
   23542     case 1383: value = 2044; break;	/* facgt --> faclt.  */
   23543     case 1396: value = 2045; break;	/* fcmge --> fcmle.  */
   23544     case 1398: value = 2046; break;	/* fcmgt --> fcmlt.  */
   23545     case 1404: value = 1259; break;	/* fcpy --> fmov.  */
   23546     case 1427: value = 1258; break;	/* fdup --> fmov.  */
   23547     case 1758: value = 1260; break;	/* orr --> mov.  */
   23548     case 1759: value = 2049; break;	/* orr --> orn.  */
   23549     case 1761: value = 1263; break;	/* orr --> mov.  */
   23550     case 1762: value = 1273; break;	/* orrs --> movs.  */
   23551     case 1824: value = 1268; break;	/* sel --> mov.  */
   23552     case 1825: value = 1271; break;	/* sel --> mov.  */
   23553     default: return NULL;
   23554     }
   23555 
   23556   return aarch64_opcode_table + value;
   23557 }
   23558 
   23559 const aarch64_opcode *
   23560 aarch64_find_next_alias_opcode (const aarch64_opcode *opcode)
   23561 {
   23562   /* Use the index as the key to locate the next opcode.  */
   23563   int key = opcode - aarch64_opcode_table;
   23564   int value;
   23565   switch (key)
   23566     {
   23567     case 3: value = 2; break;	/* ngc --> sbc.  */
   23568     case 5: value = 4; break;	/* ngcs --> sbcs.  */
   23569     case 8: value = 7; break;	/* cmn --> adds.  */
   23570     case 11: value = 10; break;	/* cmp --> subs.  */
   23571     case 13: value = 12; break;	/* mov --> add.  */
   23572     case 15: value = 14; break;	/* cmn --> adds.  */
   23573     case 18: value = 17; break;	/* cmp --> subs.  */
   23574     case 23: value = 22; break;	/* cmn --> adds.  */
   23575     case 25: value = 24; break;	/* neg --> sub.  */
   23576     case 27: value = 28; break;	/* cmp --> negs.  */
   23577     case 28: value = 26; break;	/* negs --> subs.  */
   23578     case 153: value = 152; break;	/* mov --> umov.  */
   23579     case 155: value = 154; break;	/* mov --> ins.  */
   23580     case 157: value = 156; break;	/* mov --> ins.  */
   23581     case 243: value = 242; break;	/* mvn --> not.  */
   23582     case 318: value = 317; break;	/* mov --> orr.  */
   23583     case 389: value = 388; break;	/* sxtl --> sshll.  */
   23584     case 391: value = 390; break;	/* sxtl2 --> sshll2.  */
   23585     case 413: value = 412; break;	/* uxtl --> ushll.  */
   23586     case 415: value = 414; break;	/* uxtl2 --> ushll2.  */
   23587     case 536: value = 535; break;	/* mov --> dup.  */
   23588     case 623: value = 622; break;	/* sxtw --> sxth.  */
   23589     case 622: value = 621; break;	/* sxth --> sxtb.  */
   23590     case 621: value = 624; break;	/* sxtb --> asr.  */
   23591     case 624: value = 620; break;	/* asr --> sbfx.  */
   23592     case 620: value = 619; break;	/* sbfx --> sbfiz.  */
   23593     case 619: value = 618; break;	/* sbfiz --> sbfm.  */
   23594     case 627: value = 628; break;	/* bfc --> bfxil.  */
   23595     case 628: value = 626; break;	/* bfxil --> bfi.  */
   23596     case 626: value = 625; break;	/* bfi --> bfm.  */
   23597     case 633: value = 632; break;	/* uxth --> uxtb.  */
   23598     case 632: value = 635; break;	/* uxtb --> lsr.  */
   23599     case 635: value = 634; break;	/* lsr --> lsl.  */
   23600     case 634: value = 631; break;	/* lsl --> ubfx.  */
   23601     case 631: value = 630; break;	/* ubfx --> ubfiz.  */
   23602     case 630: value = 629; break;	/* ubfiz --> ubfm.  */
   23603     case 665: value = 664; break;	/* cset --> cinc.  */
   23604     case 664: value = 663; break;	/* cinc --> csinc.  */
   23605     case 668: value = 667; break;	/* csetm --> cinv.  */
   23606     case 667: value = 666; break;	/* cinv --> csinv.  */
   23607     case 670: value = 669; break;	/* cneg --> csneg.  */
   23608     case 688: value = 689; break;	/* rev --> rev64.  */
   23609     case 714: value = 713; break;	/* lsl --> lslv.  */
   23610     case 716: value = 715; break;	/* lsr --> lsrv.  */
   23611     case 718: value = 717; break;	/* asr --> asrv.  */
   23612     case 720: value = 719; break;	/* ror --> rorv.  */
   23613     case 723: value = 722; break;	/* cmpp --> subps.  */
   23614     case 736: value = 735; break;	/* mul --> madd.  */
   23615     case 738: value = 737; break;	/* mneg --> msub.  */
   23616     case 740: value = 739; break;	/* smull --> smaddl.  */
   23617     case 742: value = 741; break;	/* smnegl --> smsubl.  */
   23618     case 745: value = 744; break;	/* umull --> umaddl.  */
   23619     case 747: value = 746; break;	/* umnegl --> umsubl.  */
   23620     case 759: value = 758; break;	/* ror --> extr.  */
   23621     case 992: value = 991; break;	/* bic --> and.  */
   23622     case 994: value = 993; break;	/* mov --> orr.  */
   23623     case 997: value = 996; break;	/* tst --> ands.  */
   23624     case 1002: value = 1001; break;	/* uxtw --> mov.  */
   23625     case 1001: value = 1000; break;	/* mov --> orr.  */
   23626     case 1004: value = 1003; break;	/* mvn --> orn.  */
   23627     case 1008: value = 1007; break;	/* tst --> ands.  */
   23628     case 1134: value = 1038; break;	/* staddb --> ldaddb.  */
   23629     case 1135: value = 1039; break;	/* staddh --> ldaddh.  */
   23630     case 1136: value = 1040; break;	/* stadd --> ldadd.  */
   23631     case 1137: value = 1042; break;	/* staddlb --> ldaddlb.  */
   23632     case 1138: value = 1045; break;	/* staddlh --> ldaddlh.  */
   23633     case 1139: value = 1048; break;	/* staddl --> ldaddl.  */
   23634     case 1140: value = 1050; break;	/* stclrb --> ldclrb.  */
   23635     case 1141: value = 1051; break;	/* stclrh --> ldclrh.  */
   23636     case 1142: value = 1052; break;	/* stclr --> ldclr.  */
   23637     case 1143: value = 1054; break;	/* stclrlb --> ldclrlb.  */
   23638     case 1144: value = 1057; break;	/* stclrlh --> ldclrlh.  */
   23639     case 1145: value = 1060; break;	/* stclrl --> ldclrl.  */
   23640     case 1146: value = 1062; break;	/* steorb --> ldeorb.  */
   23641     case 1147: value = 1063; break;	/* steorh --> ldeorh.  */
   23642     case 1148: value = 1064; break;	/* steor --> ldeor.  */
   23643     case 1149: value = 1066; break;	/* steorlb --> ldeorlb.  */
   23644     case 1150: value = 1069; break;	/* steorlh --> ldeorlh.  */
   23645     case 1151: value = 1072; break;	/* steorl --> ldeorl.  */
   23646     case 1152: value = 1074; break;	/* stsetb --> ldsetb.  */
   23647     case 1153: value = 1075; break;	/* stseth --> ldseth.  */
   23648     case 1154: value = 1076; break;	/* stset --> ldset.  */
   23649     case 1155: value = 1078; break;	/* stsetlb --> ldsetlb.  */
   23650     case 1156: value = 1081; break;	/* stsetlh --> ldsetlh.  */
   23651     case 1157: value = 1084; break;	/* stsetl --> ldsetl.  */
   23652     case 1158: value = 1086; break;	/* stsmaxb --> ldsmaxb.  */
   23653     case 1159: value = 1087; break;	/* stsmaxh --> ldsmaxh.  */
   23654     case 1160: value = 1088; break;	/* stsmax --> ldsmax.  */
   23655     case 1161: value = 1090; break;	/* stsmaxlb --> ldsmaxlb.  */
   23656     case 1162: value = 1093; break;	/* stsmaxlh --> ldsmaxlh.  */
   23657     case 1163: value = 1096; break;	/* stsmaxl --> ldsmaxl.  */
   23658     case 1164: value = 1098; break;	/* stsminb --> ldsminb.  */
   23659     case 1165: value = 1099; break;	/* stsminh --> ldsminh.  */
   23660     case 1166: value = 1100; break;	/* stsmin --> ldsmin.  */
   23661     case 1167: value = 1102; break;	/* stsminlb --> ldsminlb.  */
   23662     case 1168: value = 1105; break;	/* stsminlh --> ldsminlh.  */
   23663     case 1169: value = 1108; break;	/* stsminl --> ldsminl.  */
   23664     case 1170: value = 1110; break;	/* stumaxb --> ldumaxb.  */
   23665     case 1171: value = 1111; break;	/* stumaxh --> ldumaxh.  */
   23666     case 1172: value = 1112; break;	/* stumax --> ldumax.  */
   23667     case 1173: value = 1114; break;	/* stumaxlb --> ldumaxlb.  */
   23668     case 1174: value = 1117; break;	/* stumaxlh --> ldumaxlh.  */
   23669     case 1175: value = 1120; break;	/* stumaxl --> ldumaxl.  */
   23670     case 1176: value = 1122; break;	/* stuminb --> lduminb.  */
   23671     case 1177: value = 1123; break;	/* stuminh --> lduminh.  */
   23672     case 1178: value = 1124; break;	/* stumin --> ldumin.  */
   23673     case 1179: value = 1126; break;	/* stuminlb --> lduminlb.  */
   23674     case 1180: value = 1129; break;	/* stuminlh --> lduminlh.  */
   23675     case 1181: value = 1132; break;	/* stuminl --> lduminl.  */
   23676     case 1183: value = 1182; break;	/* mov --> movn.  */
   23677     case 1185: value = 1184; break;	/* mov --> movz.  */
   23678     case 1239: value = 1238; break;	/* autibsp --> autibz.  */
   23679     case 1238: value = 1237; break;	/* autibz --> autiasp.  */
   23680     case 1237: value = 1236; break;	/* autiasp --> autiaz.  */
   23681     case 1236: value = 1235; break;	/* autiaz --> pacibsp.  */
   23682     case 1235: value = 1234; break;	/* pacibsp --> pacibz.  */
   23683     case 1234: value = 1233; break;	/* pacibz --> paciasp.  */
   23684     case 1233: value = 1232; break;	/* paciasp --> paciaz.  */
   23685     case 1232: value = 1211; break;	/* paciaz --> tsb.  */
   23686     case 1211: value = 1210; break;	/* tsb --> psb.  */
   23687     case 1210: value = 1209; break;	/* psb --> esb.  */
   23688     case 1209: value = 1208; break;	/* esb --> autib1716.  */
   23689     case 1208: value = 1207; break;	/* autib1716 --> autia1716.  */
   23690     case 1207: value = 1206; break;	/* autia1716 --> pacib1716.  */
   23691     case 1206: value = 1205; break;	/* pacib1716 --> pacia1716.  */
   23692     case 1205: value = 1204; break;	/* pacia1716 --> xpaclri.  */
   23693     case 1204: value = 1202; break;	/* xpaclri --> sevl.  */
   23694     case 1202: value = 1201; break;	/* sevl --> sev.  */
   23695     case 1201: value = 1200; break;	/* sev --> wfi.  */
   23696     case 1200: value = 1199; break;	/* wfi --> wfe.  */
   23697     case 1199: value = 1198; break;	/* wfe --> yield.  */
   23698     case 1198: value = 1197; break;	/* yield --> bti.  */
   23699     case 1197: value = 1196; break;	/* bti --> csdb.  */
   23700     case 1196: value = 1195; break;	/* csdb --> nop.  */
   23701     case 1195: value = 1194; break;	/* nop --> hint.  */
   23702     case 1216: value = 1215; break;	/* pssbb --> ssbb.  */
   23703     case 1215: value = 1214; break;	/* ssbb --> dfb.  */
   23704     case 1214: value = 1213; break;	/* dfb --> dsb.  */
   23705     case 1227: value = 1226; break;	/* cpp --> dvp.  */
   23706     case 1226: value = 1225; break;	/* dvp --> cfp.  */
   23707     case 1225: value = 1224; break;	/* cfp --> tlbi.  */
   23708     case 1224: value = 1223; break;	/* tlbi --> ic.  */
   23709     case 1223: value = 1222; break;	/* ic --> dc.  */
   23710     case 1222: value = 1221; break;	/* dc --> at.  */
   23711     case 1221: value = 1220; break;	/* at --> sys.  */
   23712     case 2037: value = 1287; break;	/* bic --> and.  */
   23713     case 1270: value = 1289; break;	/* mov --> and.  */
   23714     case 1274: value = 1290; break;	/* movs --> ands.  */
   23715     case 2038: value = 1325; break;	/* cmple --> cmpge.  */
   23716     case 2041: value = 1328; break;	/* cmplt --> cmpgt.  */
   23717     case 2039: value = 1330; break;	/* cmplo --> cmphi.  */
   23718     case 2040: value = 1333; break;	/* cmpls --> cmphs.  */
   23719     case 1267: value = 1355; break;	/* mov --> cpy.  */
   23720     case 1269: value = 1356; break;	/* mov --> cpy.  */
   23721     case 2048: value = 1272; break;	/* fmov --> mov.  */
   23722     case 1272: value = 1357; break;	/* mov --> cpy.  */
   23723     case 1262: value = 1369; break;	/* mov --> dup.  */
   23724     case 1264: value = 1261; break;	/* mov --> mov.  */
   23725     case 1261: value = 1370; break;	/* mov --> dup.  */
   23726     case 2047: value = 1266; break;	/* fmov --> mov.  */
   23727     case 1266: value = 1371; break;	/* mov --> dup.  */
   23728     case 1265: value = 1372; break;	/* mov --> dupm.  */
   23729     case 2042: value = 1374; break;	/* eon --> eor.  */
   23730     case 1275: value = 1376; break;	/* not --> eor.  */
   23731     case 1276: value = 1377; break;	/* nots --> eors.  */
   23732     case 2043: value = 1382; break;	/* facle --> facge.  */
   23733     case 2044: value = 1383; break;	/* faclt --> facgt.  */
   23734     case 2045: value = 1396; break;	/* fcmle --> fcmge.  */
   23735     case 2046: value = 1398; break;	/* fcmlt --> fcmgt.  */
   23736     case 1259: value = 1404; break;	/* fmov --> fcpy.  */
   23737     case 1258: value = 1427; break;	/* fmov --> fdup.  */
   23738     case 1260: value = 1758; break;	/* mov --> orr.  */
   23739     case 2049: value = 1759; break;	/* orn --> orr.  */
   23740     case 1263: value = 1761; break;	/* mov --> orr.  */
   23741     case 1273: value = 1762; break;	/* movs --> orrs.  */
   23742     case 1268: value = 1824; break;	/* mov --> sel.  */
   23743     case 1271: value = 1825; break;	/* mov --> sel.  */
   23744     default: return NULL;
   23745     }
   23746 
   23747   return aarch64_opcode_table + value;
   23748 }
   23749 
   23750 bfd_boolean
   23751 aarch64_extract_operand (const aarch64_operand *self,
   23752 			   aarch64_opnd_info *info,
   23753 			   aarch64_insn code, const aarch64_inst *inst,
   23754 			   aarch64_operand_error *errors)
   23755 {
   23756   /* Use the index as the key.  */
   23757   int key = self - aarch64_operands;
   23758   switch (key)
   23759     {
   23760     case 1:
   23761     case 2:
   23762     case 3:
   23763     case 4:
   23764     case 5:
   23765     case 6:
   23766     case 7:
   23767     case 8:
   23768     case 10:
   23769     case 11:
   23770     case 12:
   23771     case 16:
   23772     case 17:
   23773     case 18:
   23774     case 19:
   23775     case 21:
   23776     case 22:
   23777     case 23:
   23778     case 24:
   23779     case 25:
   23780     case 26:
   23781     case 27:
   23782     case 28:
   23783     case 29:
   23784     case 30:
   23785     case 164:
   23786     case 165:
   23787     case 166:
   23788     case 167:
   23789     case 168:
   23790     case 169:
   23791     case 170:
   23792     case 171:
   23793     case 172:
   23794     case 173:
   23795     case 188:
   23796     case 189:
   23797     case 190:
   23798     case 191:
   23799     case 192:
   23800     case 193:
   23801     case 194:
   23802     case 195:
   23803     case 196:
   23804     case 202:
   23805     case 205:
   23806       return aarch64_ext_regno (self, info, code, inst, errors);
   23807     case 9:
   23808       return aarch64_ext_regrt_sysins (self, info, code, inst, errors);
   23809     case 13:
   23810       return aarch64_ext_regno_pair (self, info, code, inst, errors);
   23811     case 14:
   23812       return aarch64_ext_reg_extended (self, info, code, inst, errors);
   23813     case 15:
   23814       return aarch64_ext_reg_shifted (self, info, code, inst, errors);
   23815     case 20:
   23816       return aarch64_ext_ft (self, info, code, inst, errors);
   23817     case 31:
   23818     case 32:
   23819     case 33:
   23820     case 34:
   23821     case 208:
   23822       return aarch64_ext_reglane (self, info, code, inst, errors);
   23823     case 35:
   23824       return aarch64_ext_reglist (self, info, code, inst, errors);
   23825     case 36:
   23826       return aarch64_ext_ldst_reglist (self, info, code, inst, errors);
   23827     case 37:
   23828       return aarch64_ext_ldst_reglist_r (self, info, code, inst, errors);
   23829     case 38:
   23830       return aarch64_ext_ldst_elemlist (self, info, code, inst, errors);
   23831     case 39:
   23832     case 40:
   23833     case 41:
   23834     case 42:
   23835     case 52:
   23836     case 53:
   23837     case 54:
   23838     case 55:
   23839     case 56:
   23840     case 57:
   23841     case 58:
   23842     case 59:
   23843     case 60:
   23844     case 61:
   23845     case 62:
   23846     case 63:
   23847     case 64:
   23848     case 65:
   23849     case 66:
   23850     case 67:
   23851     case 68:
   23852     case 79:
   23853     case 80:
   23854     case 81:
   23855     case 82:
   23856     case 83:
   23857     case 161:
   23858     case 163:
   23859     case 180:
   23860     case 181:
   23861     case 182:
   23862     case 183:
   23863     case 184:
   23864     case 185:
   23865     case 186:
   23866     case 187:
   23867     case 207:
   23868       return aarch64_ext_imm (self, info, code, inst, errors);
   23869     case 43:
   23870     case 44:
   23871       return aarch64_ext_advsimd_imm_shift (self, info, code, inst, errors);
   23872     case 45:
   23873     case 46:
   23874     case 47:
   23875       return aarch64_ext_advsimd_imm_modified (self, info, code, inst, errors);
   23876     case 48:
   23877       return aarch64_ext_shll_imm (self, info, code, inst, errors);
   23878     case 51:
   23879     case 151:
   23880       return aarch64_ext_fpimm (self, info, code, inst, errors);
   23881     case 69:
   23882     case 159:
   23883       return aarch64_ext_limm (self, info, code, inst, errors);
   23884     case 70:
   23885       return aarch64_ext_aimm (self, info, code, inst, errors);
   23886     case 71:
   23887       return aarch64_ext_imm_half (self, info, code, inst, errors);
   23888     case 72:
   23889       return aarch64_ext_fbits (self, info, code, inst, errors);
   23890     case 74:
   23891     case 75:
   23892     case 156:
   23893       return aarch64_ext_imm_rotate2 (self, info, code, inst, errors);
   23894     case 76:
   23895     case 155:
   23896     case 157:
   23897       return aarch64_ext_imm_rotate1 (self, info, code, inst, errors);
   23898     case 77:
   23899     case 78:
   23900       return aarch64_ext_cond (self, info, code, inst, errors);
   23901     case 84:
   23902     case 93:
   23903       return aarch64_ext_addr_simple (self, info, code, inst, errors);
   23904     case 85:
   23905       return aarch64_ext_addr_regoff (self, info, code, inst, errors);
   23906     case 86:
   23907     case 87:
   23908     case 88:
   23909     case 90:
   23910     case 92:
   23911       return aarch64_ext_addr_simm (self, info, code, inst, errors);
   23912     case 89:
   23913       return aarch64_ext_addr_simm10 (self, info, code, inst, errors);
   23914     case 91:
   23915       return aarch64_ext_addr_uimm12 (self, info, code, inst, errors);
   23916     case 94:
   23917       return aarch64_ext_addr_offset (self, info, code, inst, errors);
   23918     case 95:
   23919       return aarch64_ext_simd_addr_post (self, info, code, inst, errors);
   23920     case 96:
   23921       return aarch64_ext_sysreg (self, info, code, inst, errors);
   23922     case 97:
   23923       return aarch64_ext_pstatefield (self, info, code, inst, errors);
   23924     case 98:
   23925     case 99:
   23926     case 100:
   23927     case 101:
   23928     case 102:
   23929       return aarch64_ext_sysins_op (self, info, code, inst, errors);
   23930     case 103:
   23931     case 104:
   23932       return aarch64_ext_barrier (self, info, code, inst, errors);
   23933     case 105:
   23934       return aarch64_ext_prfop (self, info, code, inst, errors);
   23935     case 106:
   23936       return aarch64_ext_none (self, info, code, inst, errors);
   23937     case 107:
   23938       return aarch64_ext_hint (self, info, code, inst, errors);
   23939     case 108:
   23940     case 109:
   23941       return aarch64_ext_sve_addr_ri_s4 (self, info, code, inst, errors);
   23942     case 110:
   23943     case 111:
   23944     case 112:
   23945     case 113:
   23946       return aarch64_ext_sve_addr_ri_s4xvl (self, info, code, inst, errors);
   23947     case 114:
   23948       return aarch64_ext_sve_addr_ri_s6xvl (self, info, code, inst, errors);
   23949     case 115:
   23950       return aarch64_ext_sve_addr_ri_s9xvl (self, info, code, inst, errors);
   23951     case 116:
   23952     case 117:
   23953     case 118:
   23954     case 119:
   23955       return aarch64_ext_sve_addr_ri_u6 (self, info, code, inst, errors);
   23956     case 120:
   23957     case 121:
   23958     case 122:
   23959     case 123:
   23960     case 124:
   23961     case 125:
   23962     case 126:
   23963     case 127:
   23964     case 128:
   23965     case 129:
   23966     case 130:
   23967     case 131:
   23968     case 132:
   23969     case 133:
   23970       return aarch64_ext_sve_addr_rr_lsl (self, info, code, inst, errors);
   23971     case 134:
   23972     case 135:
   23973     case 136:
   23974     case 137:
   23975     case 138:
   23976     case 139:
   23977     case 140:
   23978     case 141:
   23979       return aarch64_ext_sve_addr_rz_xtw (self, info, code, inst, errors);
   23980     case 142:
   23981     case 143:
   23982     case 144:
   23983     case 145:
   23984       return aarch64_ext_sve_addr_zi_u5 (self, info, code, inst, errors);
   23985     case 146:
   23986       return aarch64_ext_sve_addr_zz_lsl (self, info, code, inst, errors);
   23987     case 147:
   23988       return aarch64_ext_sve_addr_zz_sxtw (self, info, code, inst, errors);
   23989     case 148:
   23990       return aarch64_ext_sve_addr_zz_uxtw (self, info, code, inst, errors);
   23991     case 149:
   23992       return aarch64_ext_sve_aimm (self, info, code, inst, errors);
   23993     case 150:
   23994       return aarch64_ext_sve_asimm (self, info, code, inst, errors);
   23995     case 152:
   23996       return aarch64_ext_sve_float_half_one (self, info, code, inst, errors);
   23997     case 153:
   23998       return aarch64_ext_sve_float_half_two (self, info, code, inst, errors);
   23999     case 154:
   24000       return aarch64_ext_sve_float_zero_one (self, info, code, inst, errors);
   24001     case 158:
   24002       return aarch64_ext_inv_limm (self, info, code, inst, errors);
   24003     case 160:
   24004       return aarch64_ext_sve_limm_mov (self, info, code, inst, errors);
   24005     case 162:
   24006       return aarch64_ext_sve_scale (self, info, code, inst, errors);
   24007     case 174:
   24008     case 175:
   24009     case 176:
   24010       return aarch64_ext_sve_shlimm (self, info, code, inst, errors);
   24011     case 177:
   24012     case 178:
   24013     case 179:
   24014       return aarch64_ext_sve_shrimm (self, info, code, inst, errors);
   24015     case 197:
   24016     case 198:
   24017     case 199:
   24018     case 200:
   24019     case 201:
   24020       return aarch64_ext_sve_quad_index (self, info, code, inst, errors);
   24021     case 203:
   24022       return aarch64_ext_sve_index (self, info, code, inst, errors);
   24023     case 204:
   24024     case 206:
   24025       return aarch64_ext_sve_reglist (self, info, code, inst, errors);
   24026     default: assert (0); abort ();
   24027     }
   24028 }
   24029