Home | History | Annotate | Line # | Download | only in opcodes
aarch64-dis-2.c revision 1.1.1.1
      1 /* This file is automatically generated by aarch64-gen.  Do not edit!  */
      2 /* Copyright 2012, 2013  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 >> 31) & 0x1) == 0)
     38                     {
     39                       /* 33222222222211111111110000000000
     40                          10987654321098765432109876543210
     41                          xxxxxxxxxxxxxxxxxxxxxxxx0000xxx0
     42                          adr.  */
     43                       return 773;
     44                     }
     45                   else
     46                     {
     47                       /* 33222222222211111111110000000000
     48                          10987654321098765432109876543210
     49                          xxxxxxxxxxxxxxxxxxxxxxxx0000xxx1
     50                          adrp.  */
     51                       return 774;
     52                     }
     53                 }
     54               else
     55                 {
     56                   if (((word >> 29) & 0x1) == 0)
     57                     {
     58                       if (((word >> 30) & 0x1) == 0)
     59                         {
     60                           /* 33222222222211111111110000000000
     61                              10987654321098765432109876543210
     62                              xxxxxxxxxxxxxxxxxxxxxxxx1000x00x
     63                              add.  */
     64                           return 12;
     65                         }
     66                       else
     67                         {
     68                           /* 33222222222211111111110000000000
     69                              10987654321098765432109876543210
     70                              xxxxxxxxxxxxxxxxxxxxxxxx1000x01x
     71                              sub.  */
     72                           return 16;
     73                         }
     74                     }
     75                   else
     76                     {
     77                       if (((word >> 30) & 0x1) == 0)
     78                         {
     79                           /* 33222222222211111111110000000000
     80                              10987654321098765432109876543210
     81                              xxxxxxxxxxxxxxxxxxxxxxxx1000x10x
     82                              adds.  */
     83                           return 14;
     84                         }
     85                       else
     86                         {
     87                           /* 33222222222211111111110000000000
     88                              10987654321098765432109876543210
     89                              xxxxxxxxxxxxxxxxxxxxxxxx1000x11x
     90                              subs.  */
     91                           return 17;
     92                         }
     93                     }
     94                 }
     95             }
     96           else
     97             {
     98               if (((word >> 28) & 0x1) == 0)
     99                 {
    100                   if (((word >> 22) & 0x1) == 0)
    101                     {
    102                       if (((word >> 23) & 0x1) == 0)
    103                         {
    104                           if (((word >> 29) & 0x1) == 0)
    105                             {
    106                               if (((word >> 15) & 0x1) == 0)
    107                                 {
    108                                   if (((word >> 21) & 0x1) == 0)
    109                                     {
    110                                       if (((word >> 31) & 0x1) == 0)
    111                                         {
    112                                           if (((word >> 30) & 0x1) == 0)
    113                                             {
    114                                               /* 33222222222211111111110000000000
    115                                                  10987654321098765432109876543210
    116                                                  xxxxxxxxxxxxxxx0xxxxx000x0010000
    117                                                  stxrb.  */
    118                                               return 709;
    119                                             }
    120                                           else
    121                                             {
    122                                               /* 33222222222211111111110000000000
    123                                                  10987654321098765432109876543210
    124                                                  xxxxxxxxxxxxxxx0xxxxx000x0010010
    125                                                  stxrh.  */
    126                                               return 715;
    127                                             }
    128                                         }
    129                                       else
    130                                         {
    131                                           /* 33222222222211111111110000000000
    132                                              10987654321098765432109876543210
    133                                              xxxxxxxxxxxxxxx0xxxxx000x00100x1
    134                                              stxr.  */
    135                                           return 721;
    136                                         }
    137                                     }
    138                                   else
    139                                     {
    140                                       /* 33222222222211111111110000000000
    141                                          10987654321098765432109876543210
    142                                          xxxxxxxxxxxxxxx0xxxxx100x00100xx
    143                                          stxp.  */
    144                                       return 723;
    145                                     }
    146                                 }
    147                               else
    148                                 {
    149                                   if (((word >> 21) & 0x1) == 0)
    150                                     {
    151                                       if (((word >> 31) & 0x1) == 0)
    152                                         {
    153                                           if (((word >> 30) & 0x1) == 0)
    154                                             {
    155                                               /* 33222222222211111111110000000000
    156                                                  10987654321098765432109876543210
    157                                                  xxxxxxxxxxxxxxx1xxxxx000x0010000
    158                                                  stlxrb.  */
    159                                               return 710;
    160                                             }
    161                                           else
    162                                             {
    163                                               /* 33222222222211111111110000000000
    164                                                  10987654321098765432109876543210
    165                                                  xxxxxxxxxxxxxxx1xxxxx000x0010010
    166                                                  stlxrh.  */
    167                                               return 716;
    168                                             }
    169                                         }
    170                                       else
    171                                         {
    172                                           /* 33222222222211111111110000000000
    173                                              10987654321098765432109876543210
    174                                              xxxxxxxxxxxxxxx1xxxxx000x00100x1
    175                                              stlxr.  */
    176                                           return 722;
    177                                         }
    178                                     }
    179                                   else
    180                                     {
    181                                       /* 33222222222211111111110000000000
    182                                          10987654321098765432109876543210
    183                                          xxxxxxxxxxxxxxx1xxxxx100x00100xx
    184                                          stlxp.  */
    185                                       return 724;
    186                                     }
    187                                 }
    188                             }
    189                           else
    190                             {
    191                               /* 33222222222211111111110000000000
    192                                  10987654321098765432109876543210
    193                                  xxxxxxxxxxxxxxxxxxxxxx00x00101xx
    194                                  stnp.  */
    195                               return 731;
    196                             }
    197                         }
    198                       else
    199                         {
    200                           if (((word >> 29) & 0x1) == 0)
    201                             {
    202                               if (((word >> 31) & 0x1) == 0)
    203                                 {
    204                                   if (((word >> 30) & 0x1) == 0)
    205                                     {
    206                                       /* 33222222222211111111110000000000
    207                                          10987654321098765432109876543210
    208                                          xxxxxxxxxxxxxxxxxxxxxx01x0010000
    209                                          stlrb.  */
    210                                       return 713;
    211                                     }
    212                                   else
    213                                     {
    214                                       /* 33222222222211111111110000000000
    215                                          10987654321098765432109876543210
    216                                          xxxxxxxxxxxxxxxxxxxxxx01x0010010
    217                                          stlrh.  */
    218                                       return 719;
    219                                     }
    220                                 }
    221                               else
    222                                 {
    223                                   /* 33222222222211111111110000000000
    224                                      10987654321098765432109876543210
    225                                      xxxxxxxxxxxxxxxxxxxxxx01x00100x1
    226                                      stlr.  */
    227                                   return 729;
    228                                 }
    229                             }
    230                           else
    231                             {
    232                               /* 33222222222211111111110000000000
    233                                  10987654321098765432109876543210
    234                                  xxxxxxxxxxxxxxxxxxxxxx01x00101xx
    235                                  stp.  */
    236                               return 740;
    237                             }
    238                         }
    239                     }
    240                   else
    241                     {
    242                       if (((word >> 23) & 0x1) == 0)
    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                                           if (((word >> 30) & 0x1) == 0)
    253                                             {
    254                                               /* 33222222222211111111110000000000
    255                                                  10987654321098765432109876543210
    256                                                  xxxxxxxxxxxxxxx0xxxxx010x0010000
    257                                                  ldxrb.  */
    258                                               return 711;
    259                                             }
    260                                           else
    261                                             {
    262                                               /* 33222222222211111111110000000000
    263                                                  10987654321098765432109876543210
    264                                                  xxxxxxxxxxxxxxx0xxxxx010x0010010
    265                                                  ldxrh.  */
    266                                               return 717;
    267                                             }
    268                                         }
    269                                       else
    270                                         {
    271                                           /* 33222222222211111111110000000000
    272                                              10987654321098765432109876543210
    273                                              xxxxxxxxxxxxxxx0xxxxx010x00100x1
    274                                              ldxr.  */
    275                                           return 725;
    276                                         }
    277                                     }
    278                                   else
    279                                     {
    280                                       /* 33222222222211111111110000000000
    281                                          10987654321098765432109876543210
    282                                          xxxxxxxxxxxxxxx0xxxxx110x00100xx
    283                                          ldxp.  */
    284                                       return 727;
    285                                     }
    286                                 }
    287                               else
    288                                 {
    289                                   if (((word >> 21) & 0x1) == 0)
    290                                     {
    291                                       if (((word >> 31) & 0x1) == 0)
    292                                         {
    293                                           if (((word >> 30) & 0x1) == 0)
    294                                             {
    295                                               /* 33222222222211111111110000000000
    296                                                  10987654321098765432109876543210
    297                                                  xxxxxxxxxxxxxxx1xxxxx010x0010000
    298                                                  ldaxrb.  */
    299                                               return 712;
    300                                             }
    301                                           else
    302                                             {
    303                                               /* 33222222222211111111110000000000
    304                                                  10987654321098765432109876543210
    305                                                  xxxxxxxxxxxxxxx1xxxxx010x0010010
    306                                                  ldaxrh.  */
    307                                               return 718;
    308                                             }
    309                                         }
    310                                       else
    311                                         {
    312                                           /* 33222222222211111111110000000000
    313                                              10987654321098765432109876543210
    314                                              xxxxxxxxxxxxxxx1xxxxx010x00100x1
    315                                              ldaxr.  */
    316                                           return 726;
    317                                         }
    318                                     }
    319                                   else
    320                                     {
    321                                       /* 33222222222211111111110000000000
    322                                          10987654321098765432109876543210
    323                                          xxxxxxxxxxxxxxx1xxxxx110x00100xx
    324                                          ldaxp.  */
    325                                       return 728;
    326                                     }
    327                                 }
    328                             }
    329                           else
    330                             {
    331                               if (((word >> 30) & 0x1) == 0)
    332                                 {
    333                                   /* 33222222222211111111110000000000
    334                                      10987654321098765432109876543210
    335                                      xxxxxxxxxxxxxxxxxxxxxx10x001010x
    336                                      ldnp.  */
    337                                   return 732;
    338                                 }
    339                               else
    340                                 {
    341                                   /* 33222222222211111111110000000000
    342                                      10987654321098765432109876543210
    343                                      xxxxxxxxxxxxxxxxxxxxxx10x001011x
    344                                      ldpsw.  */
    345                                   return 739;
    346                                 }
    347                             }
    348                         }
    349                       else
    350                         {
    351                           if (((word >> 29) & 0x1) == 0)
    352                             {
    353                               if (((word >> 31) & 0x1) == 0)
    354                                 {
    355                                   if (((word >> 30) & 0x1) == 0)
    356                                     {
    357                                       /* 33222222222211111111110000000000
    358                                          10987654321098765432109876543210
    359                                          xxxxxxxxxxxxxxxxxxxxxx11x0010000
    360                                          ldarb.  */
    361                                       return 714;
    362                                     }
    363                                   else
    364                                     {
    365                                       /* 33222222222211111111110000000000
    366                                          10987654321098765432109876543210
    367                                          xxxxxxxxxxxxxxxxxxxxxx11x0010010
    368                                          ldarh.  */
    369                                       return 720;
    370                                     }
    371                                 }
    372                               else
    373                                 {
    374                                   /* 33222222222211111111110000000000
    375                                      10987654321098765432109876543210
    376                                      xxxxxxxxxxxxxxxxxxxxxx11x00100x1
    377                                      ldar.  */
    378                                   return 730;
    379                                 }
    380                             }
    381                           else
    382                             {
    383                               if (((word >> 30) & 0x1) == 0)
    384                                 {
    385                                   /* 33222222222211111111110000000000
    386                                      10987654321098765432109876543210
    387                                      xxxxxxxxxxxxxxxxxxxxxx11x001010x
    388                                      ldp.  */
    389                                   return 741;
    390                                 }
    391                               else
    392                                 {
    393                                   /* 33222222222211111111110000000000
    394                                      10987654321098765432109876543210
    395                                      xxxxxxxxxxxxxxxxxxxxxx11x001011x
    396                                      ldpsw.  */
    397                                   return 744;
    398                                 }
    399                             }
    400                         }
    401                     }
    402                 }
    403               else
    404                 {
    405                   if (((word >> 24) & 0x1) == 0)
    406                     {
    407                       if (((word >> 29) & 0x1) == 0)
    408                         {
    409                           if (((word >> 31) & 0x1) == 0)
    410                             {
    411                               /* 33222222222211111111110000000000
    412                                  10987654321098765432109876543210
    413                                  xxxxxxxxxxxxxxxxxxxxxxxx000110x0
    414                                  ldr.  */
    415                               return 745;
    416                             }
    417                           else
    418                             {
    419                               if (((word >> 30) & 0x1) == 0)
    420                                 {
    421                                   /* 33222222222211111111110000000000
    422                                      10987654321098765432109876543210
    423                                      xxxxxxxxxxxxxxxxxxxxxxxx00011001
    424                                      ldrsw.  */
    425                                   return 747;
    426                                 }
    427                               else
    428                                 {
    429                                   /* 33222222222211111111110000000000
    430                                      10987654321098765432109876543210
    431                                      xxxxxxxxxxxxxxxxxxxxxxxx00011011
    432                                      prfm.  */
    433                                   return 748;
    434                                 }
    435                             }
    436                         }
    437                       else
    438                         {
    439                           if (((word >> 10) & 0x1) == 0)
    440                             {
    441                               if (((word >> 11) & 0x1) == 0)
    442                                 {
    443                                   if (((word >> 23) & 0x1) == 0)
    444                                     {
    445                                       if (((word >> 22) & 0x1) == 0)
    446                                         {
    447                                           if (((word >> 31) & 0x1) == 0)
    448                                             {
    449                                               if (((word >> 30) & 0x1) == 0)
    450                                                 {
    451                                                   /* 33222222222211111111110000000000
    452                                                      10987654321098765432109876543210
    453                                                      xxxxxxxxxx00xxxxxxxxxx0000011100
    454                                                      sturb.  */
    455                                                   return 685;
    456                                                 }
    457                                               else
    458                                                 {
    459                                                   /* 33222222222211111111110000000000
    460                                                      10987654321098765432109876543210
    461                                                      xxxxxxxxxx00xxxxxxxxxx0000011110
    462                                                      sturh.  */
    463                                                   return 695;
    464                                                 }
    465                                             }
    466                                           else
    467                                             {
    468                                               /* 33222222222211111111110000000000
    469                                                  10987654321098765432109876543210
    470                                                  xxxxxxxxxx00xxxxxxxxxx00000111x1
    471                                                  stur.  */
    472                                               return 701;
    473                                             }
    474                                         }
    475                                       else
    476                                         {
    477                                           if (((word >> 31) & 0x1) == 0)
    478                                             {
    479                                               if (((word >> 30) & 0x1) == 0)
    480                                                 {
    481                                                   /* 33222222222211111111110000000000
    482                                                      10987654321098765432109876543210
    483                                                      xxxxxxxxxx00xxxxxxxxxx1000011100
    484                                                      ldurb.  */
    485                                                   return 686;
    486                                                 }
    487                                               else
    488                                                 {
    489                                                   /* 33222222222211111111110000000000
    490                                                      10987654321098765432109876543210
    491                                                      xxxxxxxxxx00xxxxxxxxxx1000011110
    492                                                      ldurh.  */
    493                                                   return 696;
    494                                                 }
    495                                             }
    496                                           else
    497                                             {
    498                                               /* 33222222222211111111110000000000
    499                                                  10987654321098765432109876543210
    500                                                  xxxxxxxxxx00xxxxxxxxxx10000111x1
    501                                                  ldur.  */
    502                                               return 702;
    503                                             }
    504                                         }
    505                                     }
    506                                   else
    507                                     {
    508                                       if (((word >> 30) & 0x1) == 0)
    509                                         {
    510                                           if (((word >> 31) & 0x1) == 0)
    511                                             {
    512                                               /* 33222222222211111111110000000000
    513                                                  10987654321098765432109876543210
    514                                                  xxxxxxxxxx00xxxxxxxxxxx100011100
    515                                                  ldursb.  */
    516                                               return 689;
    517                                             }
    518                                           else
    519                                             {
    520                                               /* 33222222222211111111110000000000
    521                                                  10987654321098765432109876543210
    522                                                  xxxxxxxxxx00xxxxxxxxxxx100011101
    523                                                  ldursw.  */
    524                                               return 705;
    525                                             }
    526                                         }
    527                                       else
    528                                         {
    529                                           if (((word >> 31) & 0x1) == 0)
    530                                             {
    531                                               /* 33222222222211111111110000000000
    532                                                  10987654321098765432109876543210
    533                                                  xxxxxxxxxx00xxxxxxxxxxx100011110
    534                                                  ldursh.  */
    535                                               return 699;
    536                                             }
    537                                           else
    538                                             {
    539                                               /* 33222222222211111111110000000000
    540                                                  10987654321098765432109876543210
    541                                                  xxxxxxxxxx00xxxxxxxxxxx100011111
    542                                                  prfum.  */
    543                                               return 707;
    544                                             }
    545                                         }
    546                                     }
    547                                 }
    548                               else
    549                                 {
    550                                   if (((word >> 21) & 0x1) == 0)
    551                                     {
    552                                       if (((word >> 23) & 0x1) == 0)
    553                                         {
    554                                           if (((word >> 22) & 0x1) == 0)
    555                                             {
    556                                               if (((word >> 31) & 0x1) == 0)
    557                                                 {
    558                                                   if (((word >> 30) & 0x1) == 0)
    559                                                     {
    560                                                       /* 33222222222211111111110000000000
    561                                                          10987654321098765432109876543210
    562                                                          xxxxxxxxxx01xxxxxxxxx00000011100
    563                                                          sttrb.  */
    564                                                       return 676;
    565                                                     }
    566                                                   else
    567                                                     {
    568                                                       /* 33222222222211111111110000000000
    569                                                          10987654321098765432109876543210
    570                                                          xxxxxxxxxx01xxxxxxxxx00000011110
    571                                                          sttrh.  */
    572                                                       return 679;
    573                                                     }
    574                                                 }
    575                                               else
    576                                                 {
    577                                                   /* 33222222222211111111110000000000
    578                                                      10987654321098765432109876543210
    579                                                      xxxxxxxxxx01xxxxxxxxx000000111x1
    580                                                      sttr.  */
    581                                                   return 682;
    582                                                 }
    583                                             }
    584                                           else
    585                                             {
    586                                               if (((word >> 31) & 0x1) == 0)
    587                                                 {
    588                                                   if (((word >> 30) & 0x1) == 0)
    589                                                     {
    590                                                       /* 33222222222211111111110000000000
    591                                                          10987654321098765432109876543210
    592                                                          xxxxxxxxxx01xxxxxxxxx01000011100
    593                                                          ldtrb.  */
    594                                                       return 677;
    595                                                     }
    596                                                   else
    597                                                     {
    598                                                       /* 33222222222211111111110000000000
    599                                                          10987654321098765432109876543210
    600                                                          xxxxxxxxxx01xxxxxxxxx01000011110
    601                                                          ldtrh.  */
    602                                                       return 680;
    603                                                     }
    604                                                 }
    605                                               else
    606                                                 {
    607                                                   /* 33222222222211111111110000000000
    608                                                      10987654321098765432109876543210
    609                                                      xxxxxxxxxx01xxxxxxxxx010000111x1
    610                                                      ldtr.  */
    611                                                   return 683;
    612                                                 }
    613                                             }
    614                                         }
    615                                       else
    616                                         {
    617                                           if (((word >> 30) & 0x1) == 0)
    618                                             {
    619                                               if (((word >> 31) & 0x1) == 0)
    620                                                 {
    621                                                   /* 33222222222211111111110000000000
    622                                                      10987654321098765432109876543210
    623                                                      xxxxxxxxxx01xxxxxxxxx0x100011100
    624                                                      ldtrsb.  */
    625                                                   return 678;
    626                                                 }
    627                                               else
    628                                                 {
    629                                                   /* 33222222222211111111110000000000
    630                                                      10987654321098765432109876543210
    631                                                      xxxxxxxxxx01xxxxxxxxx0x100011101
    632                                                      ldtrsw.  */
    633                                                   return 684;
    634                                                 }
    635                                             }
    636                                           else
    637                                             {
    638                                               /* 33222222222211111111110000000000
    639                                                  10987654321098765432109876543210
    640                                                  xxxxxxxxxx01xxxxxxxxx0x10001111x
    641                                                  ldtrsh.  */
    642                                               return 681;
    643                                             }
    644                                         }
    645                                     }
    646                                   else
    647                                     {
    648                                       if (((word >> 23) & 0x1) == 0)
    649                                         {
    650                                           if (((word >> 22) & 0x1) == 0)
    651                                             {
    652                                               if (((word >> 31) & 0x1) == 0)
    653                                                 {
    654                                                   if (((word >> 30) & 0x1) == 0)
    655                                                     {
    656                                                       /* 33222222222211111111110000000000
    657                                                          10987654321098765432109876543210
    658                                                          xxxxxxxxxx01xxxxxxxxx10000011100
    659                                                          strb.  */
    660                                                       return 664;
    661                                                     }
    662                                                   else
    663                                                     {
    664                                                       /* 33222222222211111111110000000000
    665                                                          10987654321098765432109876543210
    666                                                          xxxxxxxxxx01xxxxxxxxx10000011110
    667                                                          strh.  */
    668                                                       return 669;
    669                                                     }
    670                                                 }
    671                                               else
    672                                                 {
    673                                                   /* 33222222222211111111110000000000
    674                                                      10987654321098765432109876543210
    675                                                      xxxxxxxxxx01xxxxxxxxx100000111x1
    676                                                      str.  */
    677                                                   return 672;
    678                                                 }
    679                                             }
    680                                           else
    681                                             {
    682                                               if (((word >> 31) & 0x1) == 0)
    683                                                 {
    684                                                   if (((word >> 30) & 0x1) == 0)
    685                                                     {
    686                                                       /* 33222222222211111111110000000000
    687                                                          10987654321098765432109876543210
    688                                                          xxxxxxxxxx01xxxxxxxxx11000011100
    689                                                          ldrb.  */
    690                                                       return 665;
    691                                                     }
    692                                                   else
    693                                                     {
    694                                                       /* 33222222222211111111110000000000
    695                                                          10987654321098765432109876543210
    696                                                          xxxxxxxxxx01xxxxxxxxx11000011110
    697                                                          ldrh.  */
    698                                                       return 670;
    699                                                     }
    700                                                 }
    701                                               else
    702                                                 {
    703                                                   /* 33222222222211111111110000000000
    704                                                      10987654321098765432109876543210
    705                                                      xxxxxxxxxx01xxxxxxxxx110000111x1
    706                                                      ldr.  */
    707                                                   return 673;
    708                                                 }
    709                                             }
    710                                         }
    711                                       else
    712                                         {
    713                                           if (((word >> 30) & 0x1) == 0)
    714                                             {
    715                                               if (((word >> 31) & 0x1) == 0)
    716                                                 {
    717                                                   /* 33222222222211111111110000000000
    718                                                      10987654321098765432109876543210
    719                                                      xxxxxxxxxx01xxxxxxxxx1x100011100
    720                                                      ldrsb.  */
    721                                                   return 666;
    722                                                 }
    723                                               else
    724                                                 {
    725                                                   /* 33222222222211111111110000000000
    726                                                      10987654321098765432109876543210
    727                                                      xxxxxxxxxx01xxxxxxxxx1x100011101
    728                                                      ldrsw.  */
    729                                                   return 674;
    730                                                 }
    731                                             }
    732                                           else
    733                                             {
    734                                               if (((word >> 31) & 0x1) == 0)
    735                                                 {
    736                                                   /* 33222222222211111111110000000000
    737                                                      10987654321098765432109876543210
    738                                                      xxxxxxxxxx01xxxxxxxxx1x100011110
    739                                                      ldrsh.  */
    740                                                   return 671;
    741                                                 }
    742                                               else
    743                                                 {
    744                                                   /* 33222222222211111111110000000000
    745                                                      10987654321098765432109876543210
    746                                                      xxxxxxxxxx01xxxxxxxxx1x100011111
    747                                                      prfm.  */
    748                                                   return 675;
    749                                                 }
    750                                             }
    751                                         }
    752                                     }
    753                                 }
    754                             }
    755                           else
    756                             {
    757                               if (((word >> 23) & 0x1) == 0)
    758                                 {
    759                                   if (((word >> 22) & 0x1) == 0)
    760                                     {
    761                                       if (((word >> 31) & 0x1) == 0)
    762                                         {
    763                                           if (((word >> 30) & 0x1) == 0)
    764                                             {
    765                                               /* 33222222222211111111110000000000
    766                                                  10987654321098765432109876543210
    767                                                  xxxxxxxxxx1xxxxxxxxxxx0000011100
    768                                                  strb.  */
    769                                               return 641;
    770                                             }
    771                                           else
    772                                             {
    773                                               /* 33222222222211111111110000000000
    774                                                  10987654321098765432109876543210
    775                                                  xxxxxxxxxx1xxxxxxxxxxx0000011110
    776                                                  strh.  */
    777                                               return 646;
    778                                             }
    779                                         }
    780                                       else
    781                                         {
    782                                           /* 33222222222211111111110000000000
    783                                              10987654321098765432109876543210
    784                                              xxxxxxxxxx1xxxxxxxxxxx00000111x1
    785                                              str.  */
    786                                           return 649;
    787                                         }
    788                                     }
    789                                   else
    790                                     {
    791                                       if (((word >> 31) & 0x1) == 0)
    792                                         {
    793                                           if (((word >> 30) & 0x1) == 0)
    794                                             {
    795                                               /* 33222222222211111111110000000000
    796                                                  10987654321098765432109876543210
    797                                                  xxxxxxxxxx1xxxxxxxxxxx1000011100
    798                                                  ldrb.  */
    799                                               return 642;
    800                                             }
    801                                           else
    802                                             {
    803                                               /* 33222222222211111111110000000000
    804                                                  10987654321098765432109876543210
    805                                                  xxxxxxxxxx1xxxxxxxxxxx1000011110
    806                                                  ldrh.  */
    807                                               return 647;
    808                                             }
    809                                         }
    810                                       else
    811                                         {
    812                                           /* 33222222222211111111110000000000
    813                                              10987654321098765432109876543210
    814                                              xxxxxxxxxx1xxxxxxxxxxx10000111x1
    815                                              ldr.  */
    816                                           return 650;
    817                                         }
    818                                     }
    819                                 }
    820                               else
    821                                 {
    822                                   if (((word >> 30) & 0x1) == 0)
    823                                     {
    824                                       if (((word >> 31) & 0x1) == 0)
    825                                         {
    826                                           /* 33222222222211111111110000000000
    827                                              10987654321098765432109876543210
    828                                              xxxxxxxxxx1xxxxxxxxxxxx100011100
    829                                              ldrsb.  */
    830                                           return 643;
    831                                         }
    832                                       else
    833                                         {
    834                                           /* 33222222222211111111110000000000
    835                                              10987654321098765432109876543210
    836                                              xxxxxxxxxx1xxxxxxxxxxxx100011101
    837                                              ldrsw.  */
    838                                           return 651;
    839                                         }
    840                                     }
    841                                   else
    842                                     {
    843                                       /* 33222222222211111111110000000000
    844                                          10987654321098765432109876543210
    845                                          xxxxxxxxxx1xxxxxxxxxxxx10001111x
    846                                          ldrsh.  */
    847                                       return 648;
    848                                     }
    849                                 }
    850                             }
    851                         }
    852                     }
    853                   else
    854                     {
    855                       if (((word >> 23) & 0x1) == 0)
    856                         {
    857                           if (((word >> 22) & 0x1) == 0)
    858                             {
    859                               if (((word >> 31) & 0x1) == 0)
    860                                 {
    861                                   if (((word >> 30) & 0x1) == 0)
    862                                     {
    863                                       /* 33222222222211111111110000000000
    864                                          10987654321098765432109876543210
    865                                          xxxxxxxxxxxxxxxxxxxxxx0010011x00
    866                                          strb.  */
    867                                       return 652;
    868                                     }
    869                                   else
    870                                     {
    871                                       /* 33222222222211111111110000000000
    872                                          10987654321098765432109876543210
    873                                          xxxxxxxxxxxxxxxxxxxxxx0010011x10
    874                                          strh.  */
    875                                       return 657;
    876                                     }
    877                                 }
    878                               else
    879                                 {
    880                                   /* 33222222222211111111110000000000
    881                                      10987654321098765432109876543210
    882                                      xxxxxxxxxxxxxxxxxxxxxx0010011xx1
    883                                      str.  */
    884                                   return 660;
    885                                 }
    886                             }
    887                           else
    888                             {
    889                               if (((word >> 31) & 0x1) == 0)
    890                                 {
    891                                   if (((word >> 30) & 0x1) == 0)
    892                                     {
    893                                       /* 33222222222211111111110000000000
    894                                          10987654321098765432109876543210
    895                                          xxxxxxxxxxxxxxxxxxxxxx1010011x00
    896                                          ldrb.  */
    897                                       return 653;
    898                                     }
    899                                   else
    900                                     {
    901                                       /* 33222222222211111111110000000000
    902                                          10987654321098765432109876543210
    903                                          xxxxxxxxxxxxxxxxxxxxxx1010011x10
    904                                          ldrh.  */
    905                                       return 658;
    906                                     }
    907                                 }
    908                               else
    909                                 {
    910                                   /* 33222222222211111111110000000000
    911                                      10987654321098765432109876543210
    912                                      xxxxxxxxxxxxxxxxxxxxxx1010011xx1
    913                                      ldr.  */
    914                                   return 661;
    915                                 }
    916                             }
    917                         }
    918                       else
    919                         {
    920                           if (((word >> 30) & 0x1) == 0)
    921                             {
    922                               if (((word >> 31) & 0x1) == 0)
    923                                 {
    924                                   /* 33222222222211111111110000000000
    925                                      10987654321098765432109876543210
    926                                      xxxxxxxxxxxxxxxxxxxxxxx110011x00
    927                                      ldrsb.  */
    928                                   return 654;
    929                                 }
    930                               else
    931                                 {
    932                                   /* 33222222222211111111110000000000
    933                                      10987654321098765432109876543210
    934                                      xxxxxxxxxxxxxxxxxxxxxxx110011x01
    935                                      ldrsw.  */
    936                                   return 662;
    937                                 }
    938                             }
    939                           else
    940                             {
    941                               if (((word >> 31) & 0x1) == 0)
    942                                 {
    943                                   /* 33222222222211111111110000000000
    944                                      10987654321098765432109876543210
    945                                      xxxxxxxxxxxxxxxxxxxxxxx110011x10
    946                                      ldrsh.  */
    947                                   return 659;
    948                                 }
    949                               else
    950                                 {
    951                                   /* 33222222222211111111110000000000
    952                                      10987654321098765432109876543210
    953                                      xxxxxxxxxxxxxxxxxxxxxxx110011x11
    954                                      prfm.  */
    955                                   return 663;
    956                                 }
    957                             }
    958                         }
    959                     }
    960                 }
    961             }
    962         }
    963       else
    964         {
    965           if (((word >> 24) & 0x1) == 0)
    966             {
    967               if (((word >> 27) & 0x1) == 0)
    968                 {
    969                   if (((word >> 23) & 0x1) == 0)
    970                     {
    971                       if (((word >> 29) & 0x1) == 0)
    972                         {
    973                           if (((word >> 30) & 0x1) == 0)
    974                             {
    975                               /* 33222222222211111111110000000000
    976                                  10987654321098765432109876543210
    977                                  xxxxxxxxxxxxxxxxxxxxxxx00100x00x
    978                                  and.  */
    979                               return 749;
    980                             }
    981                           else
    982                             {
    983                               /* 33222222222211111111110000000000
    984                                  10987654321098765432109876543210
    985                                  xxxxxxxxxxxxxxxxxxxxxxx00100x01x
    986                                  eor.  */
    987                               return 753;
    988                             }
    989                         }
    990                       else
    991                         {
    992                           if (((word >> 30) & 0x1) == 0)
    993                             {
    994                               /* 33222222222211111111110000000000
    995                                  10987654321098765432109876543210
    996                                  xxxxxxxxxxxxxxxxxxxxxxx00100x10x
    997                                  orr.  */
    998                               return 751;
    999                             }
   1000                           else
   1001                             {
   1002                               /* 33222222222211111111110000000000
   1003                                  10987654321098765432109876543210
   1004                                  xxxxxxxxxxxxxxxxxxxxxxx00100x11x
   1005                                  ands.  */
   1006                               return 754;
   1007                             }
   1008                         }
   1009                     }
   1010                   else
   1011                     {
   1012                       if (((word >> 29) & 0x1) == 0)
   1013                         {
   1014                           if (((word >> 30) & 0x1) == 0)
   1015                             {
   1016                               /* 33222222222211111111110000000000
   1017                                  10987654321098765432109876543210
   1018                                  xxxxxxxxxxxxxxxxxxxxxxx10100x00x
   1019                                  movn.  */
   1020                               return 768;
   1021                             }
   1022                           else
   1023                             {
   1024                               /* 33222222222211111111110000000000
   1025                                  10987654321098765432109876543210
   1026                                  xxxxxxxxxxxxxxxxxxxxxxx10100x01x
   1027                                  movz.  */
   1028                               return 770;
   1029                             }
   1030                         }
   1031                       else
   1032                         {
   1033                           /* 33222222222211111111110000000000
   1034                              10987654321098765432109876543210
   1035                              xxxxxxxxxxxxxxxxxxxxxxx10100x1xx
   1036                              movk.  */
   1037                           return 772;
   1038                         }
   1039                     }
   1040                 }
   1041               else
   1042                 {
   1043                   if (((word >> 21) & 0x1) == 0)
   1044                     {
   1045                       if (((word >> 28) & 0x1) == 0)
   1046                         {
   1047                           if (((word >> 29) & 0x1) == 0)
   1048                             {
   1049                               if (((word >> 30) & 0x1) == 0)
   1050                                 {
   1051                                   /* 33222222222211111111110000000000
   1052                                      10987654321098765432109876543210
   1053                                      xxxxxxxxxxxxxxxxxxxxx0xx0101000x
   1054                                      and.  */
   1055                                   return 756;
   1056                                 }
   1057                               else
   1058                                 {
   1059                                   /* 33222222222211111111110000000000
   1060                                      10987654321098765432109876543210
   1061                                      xxxxxxxxxxxxxxxxxxxxx0xx0101001x
   1062                                      eor.  */
   1063                                   return 763;
   1064                                 }
   1065                             }
   1066                           else
   1067                             {
   1068                               if (((word >> 30) & 0x1) == 0)
   1069                                 {
   1070                                   /* 33222222222211111111110000000000
   1071                                      10987654321098765432109876543210
   1072                                      xxxxxxxxxxxxxxxxxxxxx0xx0101010x
   1073                                      orr.  */
   1074                                   return 758;
   1075                                 }
   1076                               else
   1077                                 {
   1078                                   /* 33222222222211111111110000000000
   1079                                      10987654321098765432109876543210
   1080                                      xxxxxxxxxxxxxxxxxxxxx0xx0101011x
   1081                                      ands.  */
   1082                                   return 765;
   1083                                 }
   1084                             }
   1085                         }
   1086                       else
   1087                         {
   1088                           if (((word >> 10) & 0x1) == 0)
   1089                             {
   1090                               if (((word >> 11) & 0x1) == 0)
   1091                                 {
   1092                                   if (((word >> 22) & 0x1) == 0)
   1093                                     {
   1094                                       if (((word >> 23) & 0x1) == 0)
   1095                                         {
   1096                                           if (((word >> 29) & 0x1) == 0)
   1097                                             {
   1098                                               if (((word >> 30) & 0x1) == 0)
   1099                                                 {
   1100                                                   /* 33222222222211111111110000000000
   1101                                                      10987654321098765432109876543210
   1102                                                      xxxxxxxxxx00xxxxxxxxx0000101100x
   1103                                                      adc.  */
   1104                                                   return 0;
   1105                                                 }
   1106                                               else
   1107                                                 {
   1108                                                   /* 33222222222211111111110000000000
   1109                                                      10987654321098765432109876543210
   1110                                                      xxxxxxxxxx00xxxxxxxxx0000101101x
   1111                                                      sbc.  */
   1112                                                   return 2;
   1113                                                 }
   1114                                             }
   1115                                           else
   1116                                             {
   1117                                               if (((word >> 30) & 0x1) == 0)
   1118                                                 {
   1119                                                   /* 33222222222211111111110000000000
   1120                                                      10987654321098765432109876543210
   1121                                                      xxxxxxxxxx00xxxxxxxxx0000101110x
   1122                                                      adcs.  */
   1123                                                   return 1;
   1124                                                 }
   1125                                               else
   1126                                                 {
   1127                                                   /* 33222222222211111111110000000000
   1128                                                      10987654321098765432109876543210
   1129                                                      xxxxxxxxxx00xxxxxxxxx0000101111x
   1130                                                      sbcs.  */
   1131                                                   return 4;
   1132                                                 }
   1133                                             }
   1134                                         }
   1135                                       else
   1136                                         {
   1137                                           if (((word >> 30) & 0x1) == 0)
   1138                                             {
   1139                                               /* 33222222222211111111110000000000
   1140                                                  10987654321098765432109876543210
   1141                                                  xxxxxxxxxx00xxxxxxxxx00101011x0x
   1142                                                  csel.  */
   1143                                               return 524;
   1144                                             }
   1145                                           else
   1146                                             {
   1147                                               /* 33222222222211111111110000000000
   1148                                                  10987654321098765432109876543210
   1149                                                  xxxxxxxxxx00xxxxxxxxx00101011x1x
   1150                                                  csinv.  */
   1151                                               return 528;
   1152                                             }
   1153                                         }
   1154                                     }
   1155                                   else
   1156                                     {
   1157                                       if (((word >> 23) & 0x1) == 0)
   1158                                         {
   1159                                           if (((word >> 30) & 0x1) == 0)
   1160                                             {
   1161                                               /* 33222222222211111111110000000000
   1162                                                  10987654321098765432109876543210
   1163                                                  xxxxxxxxxx00xxxxxxxxx01001011x0x
   1164                                                  ccmn.  */
   1165                                               return 522;
   1166                                             }
   1167                                           else
   1168                                             {
   1169                                               /* 33222222222211111111110000000000
   1170                                                  10987654321098765432109876543210
   1171                                                  xxxxxxxxxx00xxxxxxxxx01001011x1x
   1172                                                  ccmp.  */
   1173                                               return 523;
   1174                                             }
   1175                                         }
   1176                                       else
   1177                                         {
   1178                                           if (((word >> 12) & 0x1) == 0)
   1179                                             {
   1180                                               if (((word >> 13) & 0x1) == 0)
   1181                                                 {
   1182                                                   /* 33222222222211111111110000000000
   1183                                                      10987654321098765432109876543210
   1184                                                      xxxxxxxxxx0000xxxxxxx01101011xxx
   1185                                                      rbit.  */
   1186                                                   return 547;
   1187                                                 }
   1188                                               else
   1189                                                 {
   1190                                                   /* 33222222222211111111110000000000
   1191                                                      10987654321098765432109876543210
   1192                                                      xxxxxxxxxx0001xxxxxxx01101011xxx
   1193                                                      lslv.  */
   1194                                                   return 556;
   1195                                                 }
   1196                                             }
   1197                                           else
   1198                                             {
   1199                                               /* 33222222222211111111110000000000
   1200                                                  10987654321098765432109876543210
   1201                                                  xxxxxxxxxx001xxxxxxxx01101011xxx
   1202                                                  clz.  */
   1203                                               return 551;
   1204                                             }
   1205                                         }
   1206                                     }
   1207                                 }
   1208                               else
   1209                                 {
   1210                                   if (((word >> 23) & 0x1) == 0)
   1211                                     {
   1212                                       if (((word >> 30) & 0x1) == 0)
   1213                                         {
   1214                                           /* 33222222222211111111110000000000
   1215                                              10987654321098765432109876543210
   1216                                              xxxxxxxxxx01xxxxxxxxx0x001011x0x
   1217                                              ccmn.  */
   1218                                           return 520;
   1219                                         }
   1220                                       else
   1221                                         {
   1222                                           /* 33222222222211111111110000000000
   1223                                              10987654321098765432109876543210
   1224                                              xxxxxxxxxx01xxxxxxxxx0x001011x1x
   1225                                              ccmp.  */
   1226                                           return 521;
   1227                                         }
   1228                                     }
   1229                                   else
   1230                                     {
   1231                                       if (((word >> 13) & 0x1) == 0)
   1232                                         {
   1233                                           if (((word >> 30) & 0x1) == 0)
   1234                                             {
   1235                                               /* 33222222222211111111110000000000
   1236                                                  10987654321098765432109876543210
   1237                                                  xxxxxxxxxx01x0xxxxxxx0x101011x0x
   1238                                                  udiv.  */
   1239                                               return 554;
   1240                                             }
   1241                                           else
   1242                                             {
   1243                                               if (((word >> 31) & 0x1) == 0)
   1244                                                 {
   1245                                                   /* 33222222222211111111110000000000
   1246                                                      10987654321098765432109876543210
   1247                                                      xxxxxxxxxx01x0xxxxxxx0x101011x10
   1248                                                      rev.  */
   1249                                                   return 549;
   1250                                                 }
   1251                                               else
   1252                                                 {
   1253                                                   /* 33222222222211111111110000000000
   1254                                                      10987654321098765432109876543210
   1255                                                      xxxxxxxxxx01x0xxxxxxx0x101011x11
   1256                                                      rev32.  */
   1257                                                   return 553;
   1258                                                 }
   1259                                             }
   1260                                         }
   1261                                       else
   1262                                         {
   1263                                           /* 33222222222211111111110000000000
   1264                                              10987654321098765432109876543210
   1265                                              xxxxxxxxxx01x1xxxxxxx0x101011xxx
   1266                                              asrv.  */
   1267                                           return 560;
   1268                                         }
   1269                                     }
   1270                                 }
   1271                             }
   1272                           else
   1273                             {
   1274                               if (((word >> 11) & 0x1) == 0)
   1275                                 {
   1276                                   if (((word >> 22) & 0x1) == 0)
   1277                                     {
   1278                                       if (((word >> 30) & 0x1) == 0)
   1279                                         {
   1280                                           /* 33222222222211111111110000000000
   1281                                              10987654321098765432109876543210
   1282                                              xxxxxxxxxx10xxxxxxxxx00x01011x0x
   1283                                              csinc.  */
   1284                                           return 525;
   1285                                         }
   1286                                       else
   1287                                         {
   1288                                           /* 33222222222211111111110000000000
   1289                                              10987654321098765432109876543210
   1290                                              xxxxxxxxxx10xxxxxxxxx00x01011x1x
   1291                                              csneg.  */
   1292                                           return 531;
   1293                                         }
   1294                                     }
   1295                                   else
   1296                                     {
   1297                                       if (((word >> 12) & 0x1) == 0)
   1298                                         {
   1299                                           if (((word >> 13) & 0x1) == 0)
   1300                                             {
   1301                                               /* 33222222222211111111110000000000
   1302                                                  10987654321098765432109876543210
   1303                                                  xxxxxxxxxx1000xxxxxxx01x01011xxx
   1304                                                  rev16.  */
   1305                                               return 548;
   1306                                             }
   1307                                           else
   1308                                             {
   1309                                               /* 33222222222211111111110000000000
   1310                                                  10987654321098765432109876543210
   1311                                                  xxxxxxxxxx1001xxxxxxx01x01011xxx
   1312                                                  lsrv.  */
   1313                                               return 558;
   1314                                             }
   1315                                         }
   1316                                       else
   1317                                         {
   1318                                           /* 33222222222211111111110000000000
   1319                                              10987654321098765432109876543210
   1320                                              xxxxxxxxxx101xxxxxxxx01x01011xxx
   1321                                              cls.  */
   1322                                           return 552;
   1323                                         }
   1324                                     }
   1325                                 }
   1326                               else
   1327                                 {
   1328                                   if (((word >> 13) & 0x1) == 0)
   1329                                     {
   1330                                       if (((word >> 30) & 0x1) == 0)
   1331                                         {
   1332                                           /* 33222222222211111111110000000000
   1333                                              10987654321098765432109876543210
   1334                                              xxxxxxxxxx11x0xxxxxxx0xx01011x0x
   1335                                              sdiv.  */
   1336                                           return 555;
   1337                                         }
   1338                                       else
   1339                                         {
   1340                                           /* 33222222222211111111110000000000
   1341                                              10987654321098765432109876543210
   1342                                              xxxxxxxxxx11x0xxxxxxx0xx01011x1x
   1343                                              rev.  */
   1344                                           return 550;
   1345                                         }
   1346                                     }
   1347                                   else
   1348                                     {
   1349                                       /* 33222222222211111111110000000000
   1350                                          10987654321098765432109876543210
   1351                                          xxxxxxxxxx11x1xxxxxxx0xx01011xxx
   1352                                          rorv.  */
   1353                                       return 562;
   1354                                     }
   1355                                 }
   1356                             }
   1357                         }
   1358                     }
   1359                   else
   1360                     {
   1361                       if (((word >> 29) & 0x1) == 0)
   1362                         {
   1363                           if (((word >> 30) & 0x1) == 0)
   1364                             {
   1365                               /* 33222222222211111111110000000000
   1366                                  10987654321098765432109876543210
   1367                                  xxxxxxxxxxxxxxxxxxxxx1xx0101x00x
   1368                                  bic.  */
   1369                               return 757;
   1370                             }
   1371                           else
   1372                             {
   1373                               /* 33222222222211111111110000000000
   1374                                  10987654321098765432109876543210
   1375                                  xxxxxxxxxxxxxxxxxxxxx1xx0101x01x
   1376                                  eon.  */
   1377                               return 764;
   1378                             }
   1379                         }
   1380                       else
   1381                         {
   1382                           if (((word >> 30) & 0x1) == 0)
   1383                             {
   1384                               /* 33222222222211111111110000000000
   1385                                  10987654321098765432109876543210
   1386                                  xxxxxxxxxxxxxxxxxxxxx1xx0101x10x
   1387                                  orn.  */
   1388                               return 761;
   1389                             }
   1390                           else
   1391                             {
   1392                               /* 33222222222211111111110000000000
   1393                                  10987654321098765432109876543210
   1394                                  xxxxxxxxxxxxxxxxxxxxx1xx0101x11x
   1395                                  bics.  */
   1396                               return 767;
   1397                             }
   1398                         }
   1399                     }
   1400                 }
   1401             }
   1402           else
   1403             {
   1404               if (((word >> 27) & 0x1) == 0)
   1405                 {
   1406                   if (((word >> 23) & 0x1) == 0)
   1407                     {
   1408                       if (((word >> 29) & 0x1) == 0)
   1409                         {
   1410                           if (((word >> 30) & 0x1) == 0)
   1411                             {
   1412                               /* 33222222222211111111110000000000
   1413                                  10987654321098765432109876543210
   1414                                  xxxxxxxxxxxxxxxxxxxxxxx01100x00x
   1415                                  sbfm.  */
   1416                               return 493;
   1417                             }
   1418                           else
   1419                             {
   1420                               /* 33222222222211111111110000000000
   1421                                  10987654321098765432109876543210
   1422                                  xxxxxxxxxxxxxxxxxxxxxxx01100x01x
   1423                                  ubfm.  */
   1424                               return 503;
   1425                             }
   1426                         }
   1427                       else
   1428                         {
   1429                           /* 33222222222211111111110000000000
   1430                              10987654321098765432109876543210
   1431                              xxxxxxxxxxxxxxxxxxxxxxx01100x1xx
   1432                              bfm.  */
   1433                           return 500;
   1434                         }
   1435                     }
   1436                   else
   1437                     {
   1438                       /* 33222222222211111111110000000000
   1439                          10987654321098765432109876543210
   1440                          xxxxxxxxxxxxxxxxxxxxxxx11100xxxx
   1441                          extr.  */
   1442                       return 586;
   1443                     }
   1444                 }
   1445               else
   1446                 {
   1447                   if (((word >> 21) & 0x1) == 0)
   1448                     {
   1449                       if (((word >> 28) & 0x1) == 0)
   1450                         {
   1451                           if (((word >> 29) & 0x1) == 0)
   1452                             {
   1453                               if (((word >> 30) & 0x1) == 0)
   1454                                 {
   1455                                   /* 33222222222211111111110000000000
   1456                                      10987654321098765432109876543210
   1457                                      xxxxxxxxxxxxxxxxxxxxx0xx1101000x
   1458                                      add.  */
   1459                                   return 19;
   1460                                 }
   1461                               else
   1462                                 {
   1463                                   /* 33222222222211111111110000000000
   1464                                      10987654321098765432109876543210
   1465                                      xxxxxxxxxxxxxxxxxxxxx0xx1101001x
   1466                                      sub.  */
   1467                                   return 22;
   1468                                 }
   1469                             }
   1470                           else
   1471                             {
   1472                               if (((word >> 30) & 0x1) == 0)
   1473                                 {
   1474                                   /* 33222222222211111111110000000000
   1475                                      10987654321098765432109876543210
   1476                                      xxxxxxxxxxxxxxxxxxxxx0xx1101010x
   1477                                      adds.  */
   1478                                   return 20;
   1479                                 }
   1480                               else
   1481                                 {
   1482                                   /* 33222222222211111111110000000000
   1483                                      10987654321098765432109876543210
   1484                                      xxxxxxxxxxxxxxxxxxxxx0xx1101011x
   1485                                      subs.  */
   1486                                   return 24;
   1487                                 }
   1488                             }
   1489                         }
   1490                       else
   1491                         {
   1492                           if (((word >> 15) & 0x1) == 0)
   1493                             {
   1494                               if (((word >> 22) & 0x1) == 0)
   1495                                 {
   1496                                   /* 33222222222211111111110000000000
   1497                                      10987654321098765432109876543210
   1498                                      xxxxxxxxxxxxxxx0xxxxx00x11011xxx
   1499                                      madd.  */
   1500                                   return 564;
   1501                                 }
   1502                               else
   1503                                 {
   1504                                   if (((word >> 23) & 0x1) == 0)
   1505                                     {
   1506                                       /* 33222222222211111111110000000000
   1507                                          10987654321098765432109876543210
   1508                                          xxxxxxxxxxxxxxx0xxxxx01011011xxx
   1509                                          smulh.  */
   1510                                       return 572;
   1511                                     }
   1512                                   else
   1513                                     {
   1514                                       /* 33222222222211111111110000000000
   1515                                          10987654321098765432109876543210
   1516                                          xxxxxxxxxxxxxxx0xxxxx01111011xxx
   1517                                          umulh.  */
   1518                                       return 577;
   1519                                     }
   1520                                 }
   1521                             }
   1522                           else
   1523                             {
   1524                               /* 33222222222211111111110000000000
   1525                                  10987654321098765432109876543210
   1526                                  xxxxxxxxxxxxxxx1xxxxx0xx11011xxx
   1527                                  msub.  */
   1528                               return 566;
   1529                             }
   1530                         }
   1531                     }
   1532                   else
   1533                     {
   1534                       if (((word >> 23) & 0x1) == 0)
   1535                         {
   1536                           if (((word >> 28) & 0x1) == 0)
   1537                             {
   1538                               if (((word >> 29) & 0x1) == 0)
   1539                                 {
   1540                                   if (((word >> 30) & 0x1) == 0)
   1541                                     {
   1542                                       /* 33222222222211111111110000000000
   1543                                          10987654321098765432109876543210
   1544                                          xxxxxxxxxxxxxxxxxxxxx1x01101000x
   1545                                          add.  */
   1546                                       return 6;
   1547                                     }
   1548                                   else
   1549                                     {
   1550                                       /* 33222222222211111111110000000000
   1551                                          10987654321098765432109876543210
   1552                                          xxxxxxxxxxxxxxxxxxxxx1x01101001x
   1553                                          sub.  */
   1554                                       return 9;
   1555                                     }
   1556                                 }
   1557                               else
   1558                                 {
   1559                                   if (((word >> 30) & 0x1) == 0)
   1560                                     {
   1561                                       /* 33222222222211111111110000000000
   1562                                          10987654321098765432109876543210
   1563                                          xxxxxxxxxxxxxxxxxxxxx1x01101010x
   1564                                          adds.  */
   1565                                       return 7;
   1566                                     }
   1567                                   else
   1568                                     {
   1569                                       /* 33222222222211111111110000000000
   1570                                          10987654321098765432109876543210
   1571                                          xxxxxxxxxxxxxxxxxxxxx1x01101011x
   1572                                          subs.  */
   1573                                       return 10;
   1574                                     }
   1575                                 }
   1576                             }
   1577                           else
   1578                             {
   1579                               if (((word >> 15) & 0x1) == 0)
   1580                                 {
   1581                                   /* 33222222222211111111110000000000
   1582                                      10987654321098765432109876543210
   1583                                      xxxxxxxxxxxxxxx0xxxxx1x011011xxx
   1584                                      smaddl.  */
   1585                                   return 568;
   1586                                 }
   1587                               else
   1588                                 {
   1589                                   /* 33222222222211111111110000000000
   1590                                      10987654321098765432109876543210
   1591                                      xxxxxxxxxxxxxxx1xxxxx1x011011xxx
   1592                                      smsubl.  */
   1593                                   return 570;
   1594                                 }
   1595                             }
   1596                         }
   1597                       else
   1598                         {
   1599                           if (((word >> 15) & 0x1) == 0)
   1600                             {
   1601                               /* 33222222222211111111110000000000
   1602                                  10987654321098765432109876543210
   1603                                  xxxxxxxxxxxxxxx0xxxxx1x11101xxxx
   1604                                  umaddl.  */
   1605                               return 573;
   1606                             }
   1607                           else
   1608                             {
   1609                               /* 33222222222211111111110000000000
   1610                                  10987654321098765432109876543210
   1611                                  xxxxxxxxxxxxxxx1xxxxx1x11101xxxx
   1612                                  umsubl.  */
   1613                               return 575;
   1614                             }
   1615                         }
   1616                     }
   1617                 }
   1618             }
   1619         }
   1620     }
   1621   else
   1622     {
   1623       if (((word >> 27) & 0x1) == 0)
   1624         {
   1625           if (((word >> 29) & 0x1) == 0)
   1626             {
   1627               if (((word >> 30) & 0x1) == 0)
   1628                 {
   1629                   if (((word >> 31) & 0x1) == 0)
   1630                     {
   1631                       /* 33222222222211111111110000000000
   1632                          10987654321098765432109876543210
   1633                          xxxxxxxxxxxxxxxxxxxxxxxxxx10x000
   1634                          b.  */
   1635                       return 510;
   1636                     }
   1637                   else
   1638                     {
   1639                       /* 33222222222211111111110000000000
   1640                          10987654321098765432109876543210
   1641                          xxxxxxxxxxxxxxxxxxxxxxxxxx10x001
   1642                          bl.  */
   1643                       return 511;
   1644                     }
   1645                 }
   1646               else
   1647                 {
   1648                   if (((word >> 24) & 0x1) == 0)
   1649                     {
   1650                       if (((word >> 25) & 0x1) == 0)
   1651                         {
   1652                           if (((word >> 31) & 0x1) == 0)
   1653                             {
   1654                               /* 33222222222211111111110000000000
   1655                                  10987654321098765432109876543210
   1656                                  xxxxxxxxxxxxxxxxxxxxxxxx0010x010
   1657                                  b.c.  */
   1658                               return 519;
   1659                             }
   1660                           else
   1661                             {
   1662                               if (((word >> 0) & 0x1) == 0)
   1663                                 {
   1664                                   if (((word >> 1) & 0x1) == 0)
   1665                                     {
   1666                                       if (((word >> 21) & 0x1) == 0)
   1667                                         {
   1668                                           /* 33222222222211111111110000000000
   1669                                              10987654321098765432109876543210
   1670                                              00xxxxxxxxxxxxxxxxxxx0xx0010x011
   1671                                              hlt.  */
   1672                                           return 582;
   1673                                         }
   1674                                       else
   1675                                         {
   1676                                           /* 33222222222211111111110000000000
   1677                                              10987654321098765432109876543210
   1678                                              00xxxxxxxxxxxxxxxxxxx1xx0010x011
   1679                                              brk.  */
   1680                                           return 581;
   1681                                         }
   1682                                     }
   1683                                   else
   1684                                     {
   1685                                       if (((word >> 21) & 0x1) == 0)
   1686                                         {
   1687                                           /* 33222222222211111111110000000000
   1688                                              10987654321098765432109876543210
   1689                                              01xxxxxxxxxxxxxxxxxxx0xx0010x011
   1690                                              hvc.  */
   1691                                           return 579;
   1692                                         }
   1693                                       else
   1694                                         {
   1695                                           /* 33222222222211111111110000000000
   1696                                              10987654321098765432109876543210
   1697                                              01xxxxxxxxxxxxxxxxxxx1xx0010x011
   1698                                              dcps2.  */
   1699                                           return 584;
   1700                                         }
   1701                                     }
   1702                                 }
   1703                               else
   1704                                 {
   1705                                   if (((word >> 1) & 0x1) == 0)
   1706                                     {
   1707                                       if (((word >> 21) & 0x1) == 0)
   1708                                         {
   1709                                           /* 33222222222211111111110000000000
   1710                                              10987654321098765432109876543210
   1711                                              10xxxxxxxxxxxxxxxxxxx0xx0010x011
   1712                                              svc.  */
   1713                                           return 578;
   1714                                         }
   1715                                       else
   1716                                         {
   1717                                           /* 33222222222211111111110000000000
   1718                                              10987654321098765432109876543210
   1719                                              10xxxxxxxxxxxxxxxxxxx1xx0010x011
   1720                                              dcps1.  */
   1721                                           return 583;
   1722                                         }
   1723                                     }
   1724                                   else
   1725                                     {
   1726                                       if (((word >> 21) & 0x1) == 0)
   1727                                         {
   1728                                           /* 33222222222211111111110000000000
   1729                                              10987654321098765432109876543210
   1730                                              11xxxxxxxxxxxxxxxxxxx0xx0010x011
   1731                                              smc.  */
   1732                                           return 580;
   1733                                         }
   1734                                       else
   1735                                         {
   1736                                           /* 33222222222211111111110000000000
   1737                                              10987654321098765432109876543210
   1738                                              11xxxxxxxxxxxxxxxxxxx1xx0010x011
   1739                                              dcps3.  */
   1740                                           return 585;
   1741                                         }
   1742                                     }
   1743                                 }
   1744                             }
   1745                         }
   1746                       else
   1747                         {
   1748                           if (((word >> 21) & 0x1) == 0)
   1749                             {
   1750                               if (((word >> 22) & 0x1) == 0)
   1751                                 {
   1752                                   if (((word >> 23) & 0x1) == 0)
   1753                                     {
   1754                                       /* 33222222222211111111110000000000
   1755                                          10987654321098765432109876543210
   1756                                          xxxxxxxxxxxxxxxxxxxxx0000110x01x
   1757                                          br.  */
   1758                                       return 512;
   1759                                     }
   1760                                   else
   1761                                     {
   1762                                       /* 33222222222211111111110000000000
   1763                                          10987654321098765432109876543210
   1764                                          xxxxxxxxxxxxxxxxxxxxx0010110x01x
   1765                                          eret.  */
   1766                                       return 515;
   1767                                     }
   1768                                 }
   1769                               else
   1770                                 {
   1771                                   /* 33222222222211111111110000000000
   1772                                      10987654321098765432109876543210
   1773                                      xxxxxxxxxxxxxxxxxxxxx01x0110x01x
   1774                                      ret.  */
   1775                                   return 514;
   1776                                 }
   1777                             }
   1778                           else
   1779                             {
   1780                               if (((word >> 23) & 0x1) == 0)
   1781                                 {
   1782                                   /* 33222222222211111111110000000000
   1783                                      10987654321098765432109876543210
   1784                                      xxxxxxxxxxxxxxxxxxxxx1x00110x01x
   1785                                      blr.  */
   1786                                   return 513;
   1787                                 }
   1788                               else
   1789                                 {
   1790                                   /* 33222222222211111111110000000000
   1791                                      10987654321098765432109876543210
   1792                                      xxxxxxxxxxxxxxxxxxxxx1x10110x01x
   1793                                      drps.  */
   1794                                   return 516;
   1795                                 }
   1796                             }
   1797                         }
   1798                     }
   1799                   else
   1800                     {
   1801                       if (((word >> 20) & 0x1) == 0)
   1802                         {
   1803                           if (((word >> 19) & 0x1) == 0)
   1804                             {
   1805                               if (((word >> 12) & 0x1) == 0)
   1806                                 {
   1807                                   if (((word >> 13) & 0x1) == 0)
   1808                                     {
   1809                                       /* 33222222222211111111110000000000
   1810                                          10987654321098765432109876543210
   1811                                          xxxxxxxxxxxx00xxxxx00xxx1x10x01x
   1812                                          msr.  */
   1813                                       return 775;
   1814                                     }
   1815                                   else
   1816                                     {
   1817                                       /* 33222222222211111111110000000000
   1818                                          10987654321098765432109876543210
   1819                                          xxxxxxxxxxxx01xxxxx00xxx1x10x01x
   1820                                          hint.  */
   1821                                       return 776;
   1822                                     }
   1823                                 }
   1824                               else
   1825                                 {
   1826                                   if (((word >> 5) & 0x1) == 0)
   1827                                     {
   1828                                       if (((word >> 6) & 0x1) == 0)
   1829                                         {
   1830                                           /* 33222222222211111111110000000000
   1831                                              10987654321098765432109876543210
   1832                                              xxxxx00xxxxx1xxxxxx00xxx1x10x01x
   1833                                              dsb.  */
   1834                                           return 784;
   1835                                         }
   1836                                       else
   1837                                         {
   1838                                           if (((word >> 7) & 0x1) == 0)
   1839                                             {
   1840                                               /* 33222222222211111111110000000000
   1841                                                  10987654321098765432109876543210
   1842                                                  xxxxx010xxxx1xxxxxx00xxx1x10x01x
   1843                                                  clrex.  */
   1844                                               return 783;
   1845                                             }
   1846                                           else
   1847                                             {
   1848                                               /* 33222222222211111111110000000000
   1849                                                  10987654321098765432109876543210
   1850                                                  xxxxx011xxxx1xxxxxx00xxx1x10x01x
   1851                                                  isb.  */
   1852                                               return 786;
   1853                                             }
   1854                                         }
   1855                                     }
   1856                                   else
   1857                                     {
   1858                                       /* 33222222222211111111110000000000
   1859                                          10987654321098765432109876543210
   1860                                          xxxxx1xxxxxx1xxxxxx00xxx1x10x01x
   1861                                          dmb.  */
   1862                                       return 785;
   1863                                     }
   1864                                 }
   1865                             }
   1866                           else
   1867                             {
   1868                               if (((word >> 21) & 0x1) == 0)
   1869                                 {
   1870                                   /* 33222222222211111111110000000000
   1871                                      10987654321098765432109876543210
   1872                                      xxxxxxxxxxxxxxxxxxx100xx1x10x01x
   1873                                      sys.  */
   1874                                   return 787;
   1875                                 }
   1876                               else
   1877                                 {
   1878                                   /* 33222222222211111111110000000000
   1879                                      10987654321098765432109876543210
   1880                                      xxxxxxxxxxxxxxxxxxx101xx1x10x01x
   1881                                      sysl.  */
   1882                                   return 793;
   1883                                 }
   1884                             }
   1885                         }
   1886                       else
   1887                         {
   1888                           if (((word >> 21) & 0x1) == 0)
   1889                             {
   1890                               /* 33222222222211111111110000000000
   1891                                  10987654321098765432109876543210
   1892                                  xxxxxxxxxxxxxxxxxxxx10xx1x10x01x
   1893                                  msr.  */
   1894                               return 792;
   1895                             }
   1896                           else
   1897                             {
   1898                               /* 33222222222211111111110000000000
   1899                                  10987654321098765432109876543210
   1900                                  xxxxxxxxxxxxxxxxxxxx11xx1x10x01x
   1901                                  mrs.  */
   1902                               return 794;
   1903                             }
   1904                         }
   1905                     }
   1906                 }
   1907             }
   1908           else
   1909             {
   1910               if (((word >> 24) & 0x1) == 0)
   1911                 {
   1912                   if (((word >> 25) & 0x1) == 0)
   1913                     {
   1914                       /* 33222222222211111111110000000000
   1915                          10987654321098765432109876543210
   1916                          xxxxxxxxxxxxxxxxxxxxxxxx0010x1xx
   1917                          cbz.  */
   1918                       return 517;
   1919                     }
   1920                   else
   1921                     {
   1922                       /* 33222222222211111111110000000000
   1923                          10987654321098765432109876543210
   1924                          xxxxxxxxxxxxxxxxxxxxxxxx0110x1xx
   1925                          tbz.  */
   1926                       return 795;
   1927                     }
   1928                 }
   1929               else
   1930                 {
   1931                   if (((word >> 25) & 0x1) == 0)
   1932                     {
   1933                       /* 33222222222211111111110000000000
   1934                          10987654321098765432109876543210
   1935                          xxxxxxxxxxxxxxxxxxxxxxxx1010x1xx
   1936                          cbnz.  */
   1937                       return 518;
   1938                     }
   1939                   else
   1940                     {
   1941                       /* 33222222222211111111110000000000
   1942                          10987654321098765432109876543210
   1943                          xxxxxxxxxxxxxxxxxxxxxxxx1110x1xx
   1944                          tbnz.  */
   1945                       return 796;
   1946                     }
   1947                 }
   1948             }
   1949         }
   1950       else
   1951         {
   1952           if (((word >> 25) & 0x1) == 0)
   1953             {
   1954               if (((word >> 28) & 0x1) == 0)
   1955                 {
   1956                   if (((word >> 22) & 0x1) == 0)
   1957                     {
   1958                       if (((word >> 23) & 0x1) == 0)
   1959                         {
   1960                           if (((word >> 24) & 0x1) == 0)
   1961                             {
   1962                               if (((word >> 29) & 0x1) == 0)
   1963                                 {
   1964                                   /* 33222222222211111111110000000000
   1965                                      10987654321098765432109876543210
   1966                                      xxxxxxxxxxxxxxxxxxxxxx00001100xx
   1967                                      st4.  */
   1968                                   return 355;
   1969                                 }
   1970                               else
   1971                                 {
   1972                                   /* 33222222222211111111110000000000
   1973                                      10987654321098765432109876543210
   1974                                      xxxxxxxxxxxxxxxxxxxxxx00001101xx
   1975                                      stnp.  */
   1976                                   return 733;
   1977                                 }
   1978                             }
   1979                           else
   1980                             {
   1981                               if (((word >> 29) & 0x1) == 0)
   1982                                 {
   1983                                   if (((word >> 13) & 0x1) == 0)
   1984                                     {
   1985                                       if (((word >> 21) & 0x1) == 0)
   1986                                         {
   1987                                           /* 33222222222211111111110000000000
   1988                                              10987654321098765432109876543210
   1989                                              xxxxxxxxxxxxx0xxxxxxx000101100xx
   1990                                              st1.  */
   1991                                           return 371;
   1992                                         }
   1993                                       else
   1994                                         {
   1995                                           /* 33222222222211111111110000000000
   1996                                              10987654321098765432109876543210
   1997                                              xxxxxxxxxxxxx0xxxxxxx100101100xx
   1998                                              st2.  */
   1999                                           return 373;
   2000                                         }
   2001                                     }
   2002                                   else
   2003                                     {
   2004                                       if (((word >> 21) & 0x1) == 0)
   2005                                         {
   2006                                           /* 33222222222211111111110000000000
   2007                                              10987654321098765432109876543210
   2008                                              xxxxxxxxxxxxx1xxxxxxx000101100xx
   2009                                              st3.  */
   2010                                           return 372;
   2011                                         }
   2012                                       else
   2013                                         {
   2014                                           /* 33222222222211111111110000000000
   2015                                              10987654321098765432109876543210
   2016                                              xxxxxxxxxxxxx1xxxxxxx100101100xx
   2017                                              st4.  */
   2018                                           return 374;
   2019                                         }
   2020                                     }
   2021                                 }
   2022                               else
   2023                                 {
   2024                                   /* 33222222222211111111110000000000
   2025                                      10987654321098765432109876543210
   2026                                      xxxxxxxxxxxxxxxxxxxxxx00101101xx
   2027                                      stp.  */
   2028                                   return 737;
   2029                                 }
   2030                             }
   2031                         }
   2032                       else
   2033                         {
   2034                           if (((word >> 29) & 0x1) == 0)
   2035                             {
   2036                               if (((word >> 21) & 0x1) == 0)
   2037                                 {
   2038                                   if (((word >> 24) & 0x1) == 0)
   2039                                     {
   2040                                       /* 33222222222211111111110000000000
   2041                                          10987654321098765432109876543210
   2042                                          xxxxxxxxxxxxxxxxxxxxx001001100xx
   2043                                          st4.  */
   2044                                       return 363;
   2045                                     }
   2046                                   else
   2047                                     {
   2048                                       if (((word >> 13) & 0x1) == 0)
   2049                                         {
   2050                                           /* 33222222222211111111110000000000
   2051                                              10987654321098765432109876543210
   2052                                              xxxxxxxxxxxxx0xxxxxxx001101100xx
   2053                                              st1.  */
   2054                                           return 383;
   2055                                         }
   2056                                       else
   2057                                         {
   2058                                           /* 33222222222211111111110000000000
   2059                                              10987654321098765432109876543210
   2060                                              xxxxxxxxxxxxx1xxxxxxx001101100xx
   2061                                              st3.  */
   2062                                           return 384;
   2063                                         }
   2064                                     }
   2065                                 }
   2066                               else
   2067                                 {
   2068                                   if (((word >> 13) & 0x1) == 0)
   2069                                     {
   2070                                       /* 33222222222211111111110000000000
   2071                                          10987654321098765432109876543210
   2072                                          xxxxxxxxxxxxx0xxxxxxx101x01100xx
   2073                                          st2.  */
   2074                                       return 385;
   2075                                     }
   2076                                   else
   2077                                     {
   2078                                       /* 33222222222211111111110000000000
   2079                                          10987654321098765432109876543210
   2080                                          xxxxxxxxxxxxx1xxxxxxx101x01100xx
   2081                                          st4.  */
   2082                                       return 386;
   2083                                     }
   2084                                 }
   2085                             }
   2086                           else
   2087                             {
   2088                               /* 33222222222211111111110000000000
   2089                                  10987654321098765432109876543210
   2090                                  xxxxxxxxxxxxxxxxxxxxxx01x01101xx
   2091                                  stp.  */
   2092                               return 742;
   2093                             }
   2094                         }
   2095                     }
   2096                   else
   2097                     {
   2098                       if (((word >> 23) & 0x1) == 0)
   2099                         {
   2100                           if (((word >> 24) & 0x1) == 0)
   2101                             {
   2102                               if (((word >> 29) & 0x1) == 0)
   2103                                 {
   2104                                   /* 33222222222211111111110000000000
   2105                                      10987654321098765432109876543210
   2106                                      xxxxxxxxxxxxxxxxxxxxxx10001100xx
   2107                                      ld4.  */
   2108                                   return 359;
   2109                                 }
   2110                               else
   2111                                 {
   2112                                   /* 33222222222211111111110000000000
   2113                                      10987654321098765432109876543210
   2114                                      xxxxxxxxxxxxxxxxxxxxxx10001101xx
   2115                                      ldnp.  */
   2116                                   return 734;
   2117                                 }
   2118                             }
   2119                           else
   2120                             {
   2121                               if (((word >> 29) & 0x1) == 0)
   2122                                 {
   2123                                   if (((word >> 13) & 0x1) == 0)
   2124                                     {
   2125                                       if (((word >> 21) & 0x1) == 0)
   2126                                         {
   2127                                           /* 33222222222211111111110000000000
   2128                                              10987654321098765432109876543210
   2129                                              xxxxxxxxxxxxx0xxxxxxx010101100xx
   2130                                              ld1.  */
   2131                                           return 375;
   2132                                         }
   2133                                       else
   2134                                         {
   2135                                           /* 33222222222211111111110000000000
   2136                                              10987654321098765432109876543210
   2137                                              xxxxxxxxxxxxx0xxxxxxx110101100xx
   2138                                              ld2.  */
   2139                                           return 379;
   2140                                         }
   2141                                     }
   2142                                   else
   2143                                     {
   2144                                       if (((word >> 21) & 0x1) == 0)
   2145                                         {
   2146                                           /* 33222222222211111111110000000000
   2147                                              10987654321098765432109876543210
   2148                                              xxxxxxxxxxxxx1xxxxxxx010101100xx
   2149                                              ld3.  */
   2150                                           return 376;
   2151                                         }
   2152                                       else
   2153                                         {
   2154                                           /* 33222222222211111111110000000000
   2155                                              10987654321098765432109876543210
   2156                                              xxxxxxxxxxxxx1xxxxxxx110101100xx
   2157                                              ld4.  */
   2158                                           return 380;
   2159                                         }
   2160                                     }
   2161                                 }
   2162                               else
   2163                                 {
   2164                                   /* 33222222222211111111110000000000
   2165                                      10987654321098765432109876543210
   2166                                      xxxxxxxxxxxxxxxxxxxxxx10101101xx
   2167                                      ldp.  */
   2168                                   return 738;
   2169                                 }
   2170                             }
   2171                         }
   2172                       else
   2173                         {
   2174                           if (((word >> 29) & 0x1) == 0)
   2175                             {
   2176                               if (((word >> 21) & 0x1) == 0)
   2177                                 {
   2178                                   if (((word >> 24) & 0x1) == 0)
   2179                                     {
   2180                                       /* 33222222222211111111110000000000
   2181                                          10987654321098765432109876543210
   2182                                          xxxxxxxxxxxxxxxxxxxxx011001100xx
   2183                                          ld4.  */
   2184                                       return 367;
   2185                                     }
   2186                                   else
   2187                                     {
   2188                                       if (((word >> 13) & 0x1) == 0)
   2189                                         {
   2190                                           /* 33222222222211111111110000000000
   2191                                              10987654321098765432109876543210
   2192                                              xxxxxxxxxxxxx0xxxxxxx011101100xx
   2193                                              ld1.  */
   2194                                           return 387;
   2195                                         }
   2196                                       else
   2197                                         {
   2198                                           /* 33222222222211111111110000000000
   2199                                              10987654321098765432109876543210
   2200                                              xxxxxxxxxxxxx1xxxxxxx011101100xx
   2201                                              ld3.  */
   2202                                           return 388;
   2203                                         }
   2204                                     }
   2205                                 }
   2206                               else
   2207                                 {
   2208                                   if (((word >> 13) & 0x1) == 0)
   2209                                     {
   2210                                       /* 33222222222211111111110000000000
   2211                                          10987654321098765432109876543210
   2212                                          xxxxxxxxxxxxx0xxxxxxx111x01100xx
   2213                                          ld2.  */
   2214                                       return 391;
   2215                                     }
   2216                                   else
   2217                                     {
   2218                                       /* 33222222222211111111110000000000
   2219                                          10987654321098765432109876543210
   2220                                          xxxxxxxxxxxxx1xxxxxxx111x01100xx
   2221                                          ld4.  */
   2222                                       return 392;
   2223                                     }
   2224                                 }
   2225                             }
   2226                           else
   2227                             {
   2228                               /* 33222222222211111111110000000000
   2229                                  10987654321098765432109876543210
   2230                                  xxxxxxxxxxxxxxxxxxxxxx11x01101xx
   2231                                  ldp.  */
   2232                               return 743;
   2233                             }
   2234                         }
   2235                     }
   2236                 }
   2237               else
   2238                 {
   2239                   if (((word >> 24) & 0x1) == 0)
   2240                     {
   2241                       if (((word >> 29) & 0x1) == 0)
   2242                         {
   2243                           /* 33222222222211111111110000000000
   2244                              10987654321098765432109876543210
   2245                              xxxxxxxxxxxxxxxxxxxxxxxx001110xx
   2246                              ldr.  */
   2247                           return 746;
   2248                         }
   2249                       else
   2250                         {
   2251                           if (((word >> 10) & 0x1) == 0)
   2252                             {
   2253                               if (((word >> 11) & 0x1) == 0)
   2254                                 {
   2255                                   if (((word >> 22) & 0x1) == 0)
   2256                                     {
   2257                                       /* 33222222222211111111110000000000
   2258                                          10987654321098765432109876543210
   2259                                          xxxxxxxxxx00xxxxxxxxxx0x001111xx
   2260                                          stur.  */
   2261                                       return 691;
   2262                                     }
   2263                                   else
   2264                                     {
   2265                                       /* 33222222222211111111110000000000
   2266                                          10987654321098765432109876543210
   2267                                          xxxxxxxxxx00xxxxxxxxxx1x001111xx
   2268                                          ldur.  */
   2269                                       return 692;
   2270                                     }
   2271                                 }
   2272                               else
   2273                                 {
   2274                                   if (((word >> 22) & 0x1) == 0)
   2275                                     {
   2276                                       /* 33222222222211111111110000000000
   2277                                          10987654321098765432109876543210
   2278                                          xxxxxxxxxx01xxxxxxxxxx0x001111xx
   2279                                          str.  */
   2280                                       return 667;
   2281                                     }
   2282                                   else
   2283                                     {
   2284                                       /* 33222222222211111111110000000000
   2285                                          10987654321098765432109876543210
   2286                                          xxxxxxxxxx01xxxxxxxxxx1x001111xx
   2287                                          ldr.  */
   2288                                       return 668;
   2289                                     }
   2290                                 }
   2291                             }
   2292                           else
   2293                             {
   2294                               if (((word >> 22) & 0x1) == 0)
   2295                                 {
   2296                                   /* 33222222222211111111110000000000
   2297                                      10987654321098765432109876543210
   2298                                      xxxxxxxxxx1xxxxxxxxxxx0x001111xx
   2299                                      str.  */
   2300                                   return 644;
   2301                                 }
   2302                               else
   2303                                 {
   2304                                   /* 33222222222211111111110000000000
   2305                                      10987654321098765432109876543210
   2306                                      xxxxxxxxxx1xxxxxxxxxxx1x001111xx
   2307                                      ldr.  */
   2308                                   return 645;
   2309                                 }
   2310                             }
   2311                         }
   2312                     }
   2313                   else
   2314                     {
   2315                       if (((word >> 22) & 0x1) == 0)
   2316                         {
   2317                           /* 33222222222211111111110000000000
   2318                              10987654321098765432109876543210
   2319                              xxxxxxxxxxxxxxxxxxxxxx0x10111xxx
   2320                              str.  */
   2321                           return 655;
   2322                         }
   2323                       else
   2324                         {
   2325                           /* 33222222222211111111110000000000
   2326                              10987654321098765432109876543210
   2327                              xxxxxxxxxxxxxxxxxxxxxx1x10111xxx
   2328                              ldr.  */
   2329                           return 656;
   2330                         }
   2331                     }
   2332                 }
   2333             }
   2334           else
   2335             {
   2336               if (((word >> 24) & 0x1) == 0)
   2337                 {
   2338                   if (((word >> 21) & 0x1) == 0)
   2339                     {
   2340                       if (((word >> 28) & 0x1) == 0)
   2341                         {
   2342                           if (((word >> 10) & 0x1) == 0)
   2343                             {
   2344                               if (((word >> 29) & 0x1) == 0)
   2345                                 {
   2346                                   if (((word >> 11) & 0x1) == 0)
   2347                                     {
   2348                                       if (((word >> 12) & 0x1) == 0)
   2349                                         {
   2350                                           /* 33222222222211111111110000000000
   2351                                              10987654321098765432109876543210
   2352                                              xxxxxxxxxx000xxxxxxxx0xx011100xx
   2353                                              tbl.  */
   2354                                           return 341;
   2355                                         }
   2356                                       else
   2357                                         {
   2358                                           /* 33222222222211111111110000000000
   2359                                              10987654321098765432109876543210
   2360                                              xxxxxxxxxx001xxxxxxxx0xx011100xx
   2361                                              tbx.  */
   2362                                           return 342;
   2363                                         }
   2364                                     }
   2365                                   else
   2366                                     {
   2367                                       if (((word >> 12) & 0x1) == 0)
   2368                                         {
   2369                                           if (((word >> 14) & 0x1) == 0)
   2370                                             {
   2371                                               /* 33222222222211111111110000000000
   2372                                                  10987654321098765432109876543210
   2373                                                  xxxxxxxxxx010x0xxxxxx0xx011100xx
   2374                                                  trn1.  */
   2375                                               return 216;
   2376                                             }
   2377                                           else
   2378                                             {
   2379                                               /* 33222222222211111111110000000000
   2380                                                  10987654321098765432109876543210
   2381                                                  xxxxxxxxxx010x1xxxxxx0xx011100xx
   2382                                                  trn2.  */
   2383                                               return 219;
   2384                                             }
   2385                                         }
   2386                                       else
   2387                                         {
   2388                                           if (((word >> 13) & 0x1) == 0)
   2389                                             {
   2390                                               if (((word >> 14) & 0x1) == 0)
   2391                                                 {
   2392                                                   /* 33222222222211111111110000000000
   2393                                                      10987654321098765432109876543210
   2394                                                      xxxxxxxxxx01100xxxxxx0xx011100xx
   2395                                                      uzp1.  */
   2396                                                   return 215;
   2397                                                 }
   2398                                               else
   2399                                                 {
   2400                                                   /* 33222222222211111111110000000000
   2401                                                      10987654321098765432109876543210
   2402                                                      xxxxxxxxxx01101xxxxxx0xx011100xx
   2403                                                      uzp2.  */
   2404                                                   return 218;
   2405                                                 }
   2406                                             }
   2407                                           else
   2408                                             {
   2409                                               if (((word >> 14) & 0x1) == 0)
   2410                                                 {
   2411                                                   /* 33222222222211111111110000000000
   2412                                                      10987654321098765432109876543210
   2413                                                      xxxxxxxxxx01110xxxxxx0xx011100xx
   2414                                                      zip1.  */
   2415                                                   return 217;
   2416                                                 }
   2417                                               else
   2418                                                 {
   2419                                                   /* 33222222222211111111110000000000
   2420                                                      10987654321098765432109876543210
   2421                                                      xxxxxxxxxx01111xxxxxx0xx011100xx
   2422                                                      zip2.  */
   2423                                                   return 220;
   2424                                                 }
   2425                                             }
   2426                                         }
   2427                                     }
   2428                                 }
   2429                               else
   2430                                 {
   2431                                   /* 33222222222211111111110000000000
   2432                                      10987654321098765432109876543210
   2433                                      xxxxxxxxxx0xxxxxxxxxx0xx011101xx
   2434                                      ext.  */
   2435                                   return 119;
   2436                                 }
   2437                             }
   2438                           else
   2439                             {
   2440                               if (((word >> 29) & 0x1) == 0)
   2441                                 {
   2442                                   if (((word >> 11) & 0x1) == 0)
   2443                                     {
   2444                                       /* 33222222222211111111110000000000
   2445                                          10987654321098765432109876543210
   2446                                          xxxxxxxxxx10xxxxxxxxx0xx011100xx
   2447                                          dup.  */
   2448                                       return 135;
   2449                                     }
   2450                                   else
   2451                                     {
   2452                                       if (((word >> 12) & 0x1) == 0)
   2453                                         {
   2454                                           if (((word >> 13) & 0x1) == 0)
   2455                                             {
   2456                                               /* 33222222222211111111110000000000
   2457                                                  10987654321098765432109876543210
   2458                                                  xxxxxxxxxx1100xxxxxxx0xx011100xx
   2459                                                  dup.  */
   2460                                               return 136;
   2461                                             }
   2462                                           else
   2463                                             {
   2464                                               /* 33222222222211111111110000000000
   2465                                                  10987654321098765432109876543210
   2466                                                  xxxxxxxxxx1101xxxxxxx0xx011100xx
   2467                                                  smov.  */
   2468                                               return 137;
   2469                                             }
   2470                                         }
   2471                                       else
   2472                                         {
   2473                                           if (((word >> 13) & 0x1) == 0)
   2474                                             {
   2475                                               /* 33222222222211111111110000000000
   2476                                                  10987654321098765432109876543210
   2477                                                  xxxxxxxxxx1110xxxxxxx0xx011100xx
   2478                                                  ins.  */
   2479                                               return 140;
   2480                                             }
   2481                                           else
   2482                                             {
   2483                                               /* 33222222222211111111110000000000
   2484                                                  10987654321098765432109876543210
   2485                                                  xxxxxxxxxx1111xxxxxxx0xx011100xx
   2486                                                  umov.  */
   2487                                               return 138;
   2488                                             }
   2489                                         }
   2490                                     }
   2491                                 }
   2492                               else
   2493                                 {
   2494                                   /* 33222222222211111111110000000000
   2495                                      10987654321098765432109876543210
   2496                                      xxxxxxxxxx1xxxxxxxxxx0xx011101xx
   2497                                      ins.  */
   2498                                   return 142;
   2499                                 }
   2500                             }
   2501                         }
   2502                       else
   2503                         {
   2504                           if (((word >> 30) & 0x1) == 0)
   2505                             {
   2506                               if (((word >> 16) & 0x1) == 0)
   2507                                 {
   2508                                   if (((word >> 17) & 0x1) == 0)
   2509                                     {
   2510                                       /* 33222222222211111111110000000000
   2511                                          10987654321098765432109876543210
   2512                                          xxxxxxxxxxxxxxxx00xxx0xx01111x0x
   2513                                          fcvtzs.  */
   2514                                       return 590;
   2515                                     }
   2516                                   else
   2517                                     {
   2518                                       /* 33222222222211111111110000000000
   2519                                          10987654321098765432109876543210
   2520                                          xxxxxxxxxxxxxxxx01xxx0xx01111x0x
   2521                                          scvtf.  */
   2522                                       return 588;
   2523                                     }
   2524                                 }
   2525                               else
   2526                                 {
   2527                                   if (((word >> 17) & 0x1) == 0)
   2528                                     {
   2529                                       /* 33222222222211111111110000000000
   2530                                          10987654321098765432109876543210
   2531                                          xxxxxxxxxxxxxxxx10xxx0xx01111x0x
   2532                                          fcvtzu.  */
   2533                                       return 591;
   2534                                     }
   2535                                   else
   2536                                     {
   2537                                       /* 33222222222211111111110000000000
   2538                                          10987654321098765432109876543210
   2539                                          xxxxxxxxxxxxxxxx11xxx0xx01111x0x
   2540                                          ucvtf.  */
   2541                                       return 589;
   2542                                     }
   2543                                 }
   2544                             }
   2545                           else
   2546                             {
   2547                               if (((word >> 10) & 0x1) == 0)
   2548                                 {
   2549                                   if (((word >> 12) & 0x1) == 0)
   2550                                     {
   2551                                       if (((word >> 13) & 0x1) == 0)
   2552                                         {
   2553                                           if (((word >> 14) & 0x1) == 0)
   2554                                             {
   2555                                               /* 33222222222211111111110000000000
   2556                                                  10987654321098765432109876543210
   2557                                                  xxxxxxxxxx0x000xxxxxx0xx01111x1x
   2558                                                  sha1c.  */
   2559                                               return 540;
   2560                                             }
   2561                                           else
   2562                                             {
   2563                                               /* 33222222222211111111110000000000
   2564                                                  10987654321098765432109876543210
   2565                                                  xxxxxxxxxx0x001xxxxxx0xx01111x1x
   2566                                                  sha256h.  */
   2567                                               return 544;
   2568                                             }
   2569                                         }
   2570                                       else
   2571                                         {
   2572                                           if (((word >> 14) & 0x1) == 0)
   2573                                             {
   2574                                               /* 33222222222211111111110000000000
   2575                                                  10987654321098765432109876543210
   2576                                                  xxxxxxxxxx0x010xxxxxx0xx01111x1x
   2577                                                  sha1m.  */
   2578                                               return 542;
   2579                                             }
   2580                                           else
   2581                                             {
   2582                                               /* 33222222222211111111110000000000
   2583                                                  10987654321098765432109876543210
   2584                                                  xxxxxxxxxx0x011xxxxxx0xx01111x1x
   2585                                                  sha256su1.  */
   2586                                               return 546;
   2587                                             }
   2588                                         }
   2589                                     }
   2590                                   else
   2591                                     {
   2592                                       if (((word >> 13) & 0x1) == 0)
   2593                                         {
   2594                                           if (((word >> 14) & 0x1) == 0)
   2595                                             {
   2596                                               /* 33222222222211111111110000000000
   2597                                                  10987654321098765432109876543210
   2598                                                  xxxxxxxxxx0x100xxxxxx0xx01111x1x
   2599                                                  sha1p.  */
   2600                                               return 541;
   2601                                             }
   2602                                           else
   2603                                             {
   2604                                               /* 33222222222211111111110000000000
   2605                                                  10987654321098765432109876543210
   2606                                                  xxxxxxxxxx0x101xxxxxx0xx01111x1x
   2607                                                  sha256h2.  */
   2608                                               return 545;
   2609                                             }
   2610                                         }
   2611                                       else
   2612                                         {
   2613                                           /* 33222222222211111111110000000000
   2614                                              10987654321098765432109876543210
   2615                                              xxxxxxxxxx0x11xxxxxxx0xx01111x1x
   2616                                              sha1su0.  */
   2617                                           return 543;
   2618                                         }
   2619                                     }
   2620                                 }
   2621                               else
   2622                                 {
   2623                                   /* 33222222222211111111110000000000
   2624                                      10987654321098765432109876543210
   2625                                      xxxxxxxxxx1xxxxxxxxxx0xx01111x1x
   2626                                      dup.  */
   2627                                   return 430;
   2628                                 }
   2629                             }
   2630                         }
   2631                     }
   2632                   else
   2633                     {
   2634                       if (((word >> 10) & 0x1) == 0)
   2635                         {
   2636                           if (((word >> 11) & 0x1) == 0)
   2637                             {
   2638                               if (((word >> 12) & 0x1) == 0)
   2639                                 {
   2640                                   if (((word >> 13) & 0x1) == 0)
   2641                                     {
   2642                                       if (((word >> 14) & 0x1) == 0)
   2643                                         {
   2644                                           if (((word >> 15) & 0x1) == 0)
   2645                                             {
   2646                                               if (((word >> 28) & 0x1) == 0)
   2647                                                 {
   2648                                                   if (((word >> 29) & 0x1) == 0)
   2649                                                     {
   2650                                                       if (((word >> 30) & 0x1) == 0)
   2651                                                         {
   2652                                                           /* 33222222222211111111110000000000
   2653                                                              10987654321098765432109876543210
   2654                                                              xxxxxxxxxx000000xxxxx1xx0111000x
   2655                                                              saddl.  */
   2656                                                           return 38;
   2657                                                         }
   2658                                                       else
   2659                                                         {
   2660                                                           /* 33222222222211111111110000000000
   2661                                                              10987654321098765432109876543210
   2662                                                              xxxxxxxxxx000000xxxxx1xx0111001x
   2663                                                              saddl2.  */
   2664                                                           return 39;
   2665                                                         }
   2666                                                     }
   2667                                                   else
   2668                                                     {
   2669                                                       if (((word >> 30) & 0x1) == 0)
   2670                                                         {
   2671                                                           /* 33222222222211111111110000000000
   2672                                                              10987654321098765432109876543210
   2673                                                              xxxxxxxxxx000000xxxxx1xx0111010x
   2674                                                              uaddl.  */
   2675                                                           return 70;
   2676                                                         }
   2677                                                       else
   2678                                                         {
   2679                                                           /* 33222222222211111111110000000000
   2680                                                              10987654321098765432109876543210
   2681                                                              xxxxxxxxxx000000xxxxx1xx0111011x
   2682                                                              uaddl2.  */
   2683                                                           return 71;
   2684                                                         }
   2685                                                     }
   2686                                                 }
   2687                                               else
   2688                                                 {
   2689                                                   if (((word >> 16) & 0x1) == 0)
   2690                                                     {
   2691                                                       if (((word >> 17) & 0x1) == 0)
   2692                                                         {
   2693                                                           if (((word >> 18) & 0x1) == 0)
   2694                                                             {
   2695                                                               if (((word >> 19) & 0x1) == 0)
   2696                                                                 {
   2697                                                                   if (((word >> 20) & 0x1) == 0)
   2698                                                                     {
   2699                                                                       /* 33222222222211111111110000000000
   2700                                                                          10987654321098765432109876543210
   2701                                                                          xxxxxxxxxx000000000001xx01111xxx
   2702                                                                          fcvtns.  */
   2703                                                                       return 592;
   2704                                                                     }
   2705                                                                   else
   2706                                                                     {
   2707                                                                       /* 33222222222211111111110000000000
   2708                                                                          10987654321098765432109876543210
   2709                                                                          xxxxxxxxxx000000000011xx01111xxx
   2710                                                                          fcvtms.  */
   2711                                                                       return 602;
   2712                                                                     }
   2713                                                                 }
   2714                                                               else
   2715                                                                 {
   2716                                                                   if (((word >> 20) & 0x1) == 0)
   2717                                                                     {
   2718                                                                       /* 33222222222211111111110000000000
   2719                                                                          10987654321098765432109876543210
   2720                                                                          xxxxxxxxxx000000000101xx01111xxx
   2721                                                                          fcvtps.  */
   2722                                                                       return 600;
   2723                                                                     }
   2724                                                                   else
   2725                                                                     {
   2726                                                                       /* 33222222222211111111110000000000
   2727                                                                          10987654321098765432109876543210
   2728                                                                          xxxxxxxxxx000000000111xx01111xxx
   2729                                                                          fcvtzs.  */
   2730                                                                       return 604;
   2731                                                                     }
   2732                                                                 }
   2733                                                             }
   2734                                                           else
   2735                                                             {
   2736                                                               /* 33222222222211111111110000000000
   2737                                                                  10987654321098765432109876543210
   2738                                                                  xxxxxxxxxx000000001xx1xx01111xxx
   2739                                                                  fcvtas.  */
   2740                                                               return 596;
   2741                                                             }
   2742                                                         }
   2743                                                       else
   2744                                                         {
   2745                                                           if (((word >> 18) & 0x1) == 0)
   2746                                                             {
   2747                                                               /* 33222222222211111111110000000000
   2748                                                                  10987654321098765432109876543210
   2749                                                                  xxxxxxxxxx000000010xx1xx01111xxx
   2750                                                                  scvtf.  */
   2751                                                               return 594;
   2752                                                             }
   2753                                                           else
   2754                                                             {
   2755                                                               if (((word >> 19) & 0x1) == 0)
   2756                                                                 {
   2757                                                                   /* 33222222222211111111110000000000
   2758                                                                      10987654321098765432109876543210
   2759                                                                      xxxxxxxxxx0000000110x1xx01111xxx
   2760                                                                      fmov.  */
   2761                                                                   return 598;
   2762                                                                 }
   2763                                                               else
   2764                                                                 {
   2765                                                                   /* 33222222222211111111110000000000
   2766                                                                      10987654321098765432109876543210
   2767                                                                      xxxxxxxxxx0000000111x1xx01111xxx
   2768                                                                      fmov.  */
   2769                                                                   return 606;
   2770                                                                 }
   2771                                                             }
   2772                                                         }
   2773                                                     }
   2774                                                   else
   2775                                                     {
   2776                                                       if (((word >> 17) & 0x1) == 0)
   2777                                                         {
   2778                                                           if (((word >> 18) & 0x1) == 0)
   2779                                                             {
   2780                                                               if (((word >> 19) & 0x1) == 0)
   2781                                                                 {
   2782                                                                   if (((word >> 20) & 0x1) == 0)
   2783                                                                     {
   2784                                                                       /* 33222222222211111111110000000000
   2785                                                                          10987654321098765432109876543210
   2786                                                                          xxxxxxxxxx000000100001xx01111xxx
   2787                                                                          fcvtnu.  */
   2788                                                                       return 593;
   2789                                                                     }
   2790                                                                   else
   2791                                                                     {
   2792                                                                       /* 33222222222211111111110000000000
   2793                                                                          10987654321098765432109876543210
   2794                                                                          xxxxxxxxxx000000100011xx01111xxx
   2795                                                                          fcvtmu.  */
   2796                                                                       return 603;
   2797                                                                     }
   2798                                                                 }
   2799                                                               else
   2800                                                                 {
   2801                                                                   if (((word >> 20) & 0x1) == 0)
   2802                                                                     {
   2803                                                                       /* 33222222222211111111110000000000
   2804                                                                          10987654321098765432109876543210
   2805                                                                          xxxxxxxxxx000000100101xx01111xxx
   2806                                                                          fcvtpu.  */
   2807                                                                       return 601;
   2808                                                                     }
   2809                                                                   else
   2810                                                                     {
   2811                                                                       /* 33222222222211111111110000000000
   2812                                                                          10987654321098765432109876543210
   2813                                                                          xxxxxxxxxx000000100111xx01111xxx
   2814                                                                          fcvtzu.  */
   2815                                                                       return 605;
   2816                                                                     }
   2817                                                                 }
   2818                                                             }
   2819                                                           else
   2820                                                             {
   2821                                                               /* 33222222222211111111110000000000
   2822                                                                  10987654321098765432109876543210
   2823                                                                  xxxxxxxxxx000000101xx1xx01111xxx
   2824                                                                  fcvtau.  */
   2825                                                               return 597;
   2826                                                             }
   2827                                                         }
   2828                                                       else
   2829                                                         {
   2830                                                           if (((word >> 18) & 0x1) == 0)
   2831                                                             {
   2832                                                               /* 33222222222211111111110000000000
   2833                                                                  10987654321098765432109876543210
   2834                                                                  xxxxxxxxxx000000110xx1xx01111xxx
   2835                                                                  ucvtf.  */
   2836                                                               return 595;
   2837                                                             }
   2838                                                           else
   2839                                                             {
   2840                                                               if (((word >> 19) & 0x1) == 0)
   2841                                                                 {
   2842                                                                   /* 33222222222211111111110000000000
   2843                                                                      10987654321098765432109876543210
   2844                                                                      xxxxxxxxxx0000001110x1xx01111xxx
   2845                                                                      fmov.  */
   2846                                                                   return 599;
   2847                                                                 }
   2848                                                               else
   2849                                                                 {
   2850                                                                   /* 33222222222211111111110000000000
   2851                                                                      10987654321098765432109876543210
   2852                                                                      xxxxxxxxxx0000001111x1xx01111xxx
   2853                                                                      fmov.  */
   2854                                                                   return 607;
   2855                                                                 }
   2856                                                             }
   2857                                                         }
   2858                                                     }
   2859                                                 }
   2860                                             }
   2861                                           else
   2862                                             {
   2863                                               if (((word >> 29) & 0x1) == 0)
   2864                                                 {
   2865                                                   if (((word >> 30) & 0x1) == 0)
   2866                                                     {
   2867                                                       /* 33222222222211111111110000000000
   2868                                                          10987654321098765432109876543210
   2869                                                          xxxxxxxxxx000001xxxxx1xx0111x00x
   2870                                                          smlal.  */
   2871                                                       return 54;
   2872                                                     }
   2873                                                   else
   2874                                                     {
   2875                                                       /* 33222222222211111111110000000000
   2876                                                          10987654321098765432109876543210
   2877                                                          xxxxxxxxxx000001xxxxx1xx0111x01x
   2878                                                          smlal2.  */
   2879                                                       return 55;
   2880                                                     }
   2881                                                 }
   2882                                               else
   2883                                                 {
   2884                                                   if (((word >> 30) & 0x1) == 0)
   2885                                                     {
   2886                                                       /* 33222222222211111111110000000000
   2887                                                          10987654321098765432109876543210
   2888                                                          xxxxxxxxxx000001xxxxx1xx0111x10x
   2889                                                          umlal.  */
   2890                                                       return 86;
   2891                                                     }
   2892                                                   else
   2893                                                     {
   2894                                                       /* 33222222222211111111110000000000
   2895                                                          10987654321098765432109876543210
   2896                                                          xxxxxxxxxx000001xxxxx1xx0111x11x
   2897                                                          umlal2.  */
   2898                                                       return 87;
   2899                                                     }
   2900                                                 }
   2901                                             }
   2902                                         }
   2903                                       else
   2904                                         {
   2905                                           if (((word >> 28) & 0x1) == 0)
   2906                                             {
   2907                                               if (((word >> 15) & 0x1) == 0)
   2908                                                 {
   2909                                                   if (((word >> 29) & 0x1) == 0)
   2910                                                     {
   2911                                                       if (((word >> 30) & 0x1) == 0)
   2912                                                         {
   2913                                                           /* 33222222222211111111110000000000
   2914                                                              10987654321098765432109876543210
   2915                                                              xxxxxxxxxx000010xxxxx1xx0111000x
   2916                                                              addhn.  */
   2917                                                           return 46;
   2918                                                         }
   2919                                                       else
   2920                                                         {
   2921                                                           /* 33222222222211111111110000000000
   2922                                                              10987654321098765432109876543210
   2923                                                              xxxxxxxxxx000010xxxxx1xx0111001x
   2924                                                              addhn2.  */
   2925                                                           return 47;
   2926                                                         }
   2927                                                     }
   2928                                                   else
   2929                                                     {
   2930                                                       if (((word >> 30) & 0x1) == 0)
   2931                                                         {
   2932                                                           /* 33222222222211111111110000000000
   2933                                                              10987654321098765432109876543210
   2934                                                              xxxxxxxxxx000010xxxxx1xx0111010x
   2935                                                              raddhn.  */
   2936                                                           return 78;
   2937                                                         }
   2938                                                       else
   2939                                                         {
   2940                                                           /* 33222222222211111111110000000000
   2941                                                              10987654321098765432109876543210
   2942                                                              xxxxxxxxxx000010xxxxx1xx0111011x
   2943                                                              raddhn2.  */
   2944                                                           return 79;
   2945                                                         }
   2946                                                     }
   2947                                                 }
   2948                                               else
   2949                                                 {
   2950                                                   if (((word >> 29) & 0x1) == 0)
   2951                                                     {
   2952                                                       if (((word >> 30) & 0x1) == 0)
   2953                                                         {
   2954                                                           /* 33222222222211111111110000000000
   2955                                                              10987654321098765432109876543210
   2956                                                              xxxxxxxxxx000011xxxxx1xx0111000x
   2957                                                              smull.  */
   2958                                                           return 62;
   2959                                                         }
   2960                                                       else
   2961                                                         {
   2962                                                           /* 33222222222211111111110000000000
   2963                                                              10987654321098765432109876543210
   2964                                                              xxxxxxxxxx000011xxxxx1xx0111001x
   2965                                                              smull2.  */
   2966                                                           return 63;
   2967                                                         }
   2968                                                     }
   2969                                                   else
   2970                                                     {
   2971                                                       if (((word >> 30) & 0x1) == 0)
   2972                                                         {
   2973                                                           /* 33222222222211111111110000000000
   2974                                                              10987654321098765432109876543210
   2975                                                              xxxxxxxxxx000011xxxxx1xx0111010x
   2976                                                              umull.  */
   2977                                                           return 90;
   2978                                                         }
   2979                                                       else
   2980                                                         {
   2981                                                           /* 33222222222211111111110000000000
   2982                                                              10987654321098765432109876543210
   2983                                                              xxxxxxxxxx000011xxxxx1xx0111011x
   2984                                                              umull2.  */
   2985                                                           return 91;
   2986                                                         }
   2987                                                     }
   2988                                                 }
   2989                                             }
   2990                                           else
   2991                                             {
   2992                                               if (((word >> 17) & 0x1) == 0)
   2993                                                 {
   2994                                                   if (((word >> 15) & 0x1) == 0)
   2995                                                     {
   2996                                                       if (((word >> 16) & 0x1) == 0)
   2997                                                         {
   2998                                                           if (((word >> 18) & 0x1) == 0)
   2999                                                             {
   3000                                                               /* 33222222222211111111110000000000
   3001                                                                  10987654321098765432109876543210
   3002                                                                  xxxxxxxxxx000010000xx1xx01111xxx
   3003                                                                  fmov.  */
   3004                                                               return 614;
   3005                                                             }
   3006                                                           else
   3007                                                             {
   3008                                                               /* 33222222222211111111110000000000
   3009                                                                  10987654321098765432109876543210
   3010                                                                  xxxxxxxxxx000010001xx1xx01111xxx
   3011                                                                  frintn.  */
   3012                                                               return 619;
   3013                                                             }
   3014                                                         }
   3015                                                       else
   3016                                                         {
   3017                                                           if (((word >> 18) & 0x1) == 0)
   3018                                                             {
   3019                                                               /* 33222222222211111111110000000000
   3020                                                                  10987654321098765432109876543210
   3021                                                                  xxxxxxxxxx000010100xx1xx01111xxx
   3022                                                                  fneg.  */
   3023                                                               return 616;
   3024                                                             }
   3025                                                           else
   3026                                                             {
   3027                                                               /* 33222222222211111111110000000000
   3028                                                                  10987654321098765432109876543210
   3029                                                                  xxxxxxxxxx000010101xx1xx01111xxx
   3030                                                                  frintm.  */
   3031                                                               return 621;
   3032                                                             }
   3033                                                         }
   3034                                                     }
   3035                                                   else
   3036                                                     {
   3037                                                       if (((word >> 16) & 0x1) == 0)
   3038                                                         {
   3039                                                           if (((word >> 18) & 0x1) == 0)
   3040                                                             {
   3041                                                               /* 33222222222211111111110000000000
   3042                                                                  10987654321098765432109876543210
   3043                                                                  xxxxxxxxxx000011000xx1xx01111xxx
   3044                                                                  fabs.  */
   3045                                                               return 615;
   3046                                                             }
   3047                                                           else
   3048                                                             {
   3049                                                               /* 33222222222211111111110000000000
   3050                                                                  10987654321098765432109876543210
   3051                                                                  xxxxxxxxxx000011001xx1xx01111xxx
   3052                                                                  frintp.  */
   3053                                                               return 620;
   3054                                                             }
   3055                                                         }
   3056                                                       else
   3057                                                         {
   3058                                                           if (((word >> 18) & 0x1) == 0)
   3059                                                             {
   3060                                                               /* 33222222222211111111110000000000
   3061                                                                  10987654321098765432109876543210
   3062                                                                  xxxxxxxxxx000011100xx1xx01111xxx
   3063                                                                  fsqrt.  */
   3064                                                               return 617;
   3065                                                             }
   3066                                                           else
   3067                                                             {
   3068                                                               /* 33222222222211111111110000000000
   3069                                                                  10987654321098765432109876543210
   3070                                                                  xxxxxxxxxx000011101xx1xx01111xxx
   3071                                                                  frintz.  */
   3072                                                               return 622;
   3073                                                             }
   3074                                                         }
   3075                                                     }
   3076                                                 }
   3077                                               else
   3078                                                 {
   3079                                                   if (((word >> 18) & 0x1) == 0)
   3080                                                     {
   3081                                                       /* 33222222222211111111110000000000
   3082                                                          10987654321098765432109876543210
   3083                                                          xxxxxxxxxx00001xx10xx1xx01111xxx
   3084                                                          fcvt.  */
   3085                                                       return 618;
   3086                                                     }
   3087                                                   else
   3088                                                     {
   3089                                                       if (((word >> 15) & 0x1) == 0)
   3090                                                         {
   3091                                                           if (((word >> 16) & 0x1) == 0)
   3092                                                             {
   3093                                                               /* 33222222222211111111110000000000
   3094                                                                  10987654321098765432109876543210
   3095                                                                  xxxxxxxxxx000010011xx1xx01111xxx
   3096                                                                  frinta.  */
   3097                                                               return 623;
   3098                                                             }
   3099                                                           else
   3100                                                             {
   3101                                                               /* 33222222222211111111110000000000
   3102                                                                  10987654321098765432109876543210
   3103                                                                  xxxxxxxxxx000010111xx1xx01111xxx
   3104                                                                  frintx.  */
   3105                                                               return 624;
   3106                                                             }
   3107                                                         }
   3108                                                       else
   3109                                                         {
   3110                                                           /* 33222222222211111111110000000000
   3111                                                              10987654321098765432109876543210
   3112                                                              xxxxxxxxxx000011x11xx1xx01111xxx
   3113                                                              frinti.  */
   3114                                                           return 625;
   3115                                                         }
   3116                                                     }
   3117                                                 }
   3118                                             }
   3119                                         }
   3120                                     }
   3121                                   else
   3122                                     {
   3123                                       if (((word >> 14) & 0x1) == 0)
   3124                                         {
   3125                                           if (((word >> 15) & 0x1) == 0)
   3126                                             {
   3127                                               if (((word >> 28) & 0x1) == 0)
   3128                                                 {
   3129                                                   if (((word >> 29) & 0x1) == 0)
   3130                                                     {
   3131                                                       if (((word >> 30) & 0x1) == 0)
   3132                                                         {
   3133                                                           /* 33222222222211111111110000000000
   3134                                                              10987654321098765432109876543210
   3135                                                              xxxxxxxxxx000100xxxxx1xx0111000x
   3136                                                              ssubl.  */
   3137                                                           return 42;
   3138                                                         }
   3139                                                       else
   3140                                                         {
   3141                                                           /* 33222222222211111111110000000000
   3142                                                              10987654321098765432109876543210
   3143                                                              xxxxxxxxxx000100xxxxx1xx0111001x
   3144                                                              ssubl2.  */
   3145                                                           return 43;
   3146                                                         }
   3147                                                     }
   3148                                                   else
   3149                                                     {
   3150                                                       if (((word >> 30) & 0x1) == 0)
   3151                                                         {
   3152                                                           /* 33222222222211111111110000000000
   3153                                                              10987654321098765432109876543210
   3154                                                              xxxxxxxxxx000100xxxxx1xx0111010x
   3155                                                              usubl.  */
   3156                                                           return 74;
   3157                                                         }
   3158                                                       else
   3159                                                         {
   3160                                                           /* 33222222222211111111110000000000
   3161                                                              10987654321098765432109876543210
   3162                                                              xxxxxxxxxx000100xxxxx1xx0111011x
   3163                                                              usubl2.  */
   3164                                                           return 75;
   3165                                                         }
   3166                                                     }
   3167                                                 }
   3168                                               else
   3169                                                 {
   3170                                                   if (((word >> 3) & 0x1) == 0)
   3171                                                     {
   3172                                                       if (((word >> 4) & 0x1) == 0)
   3173                                                         {
   3174                                                           /* 33222222222211111111110000000000
   3175                                                              10987654321098765432109876543210
   3176                                                              xxx00xxxxx000100xxxxx1xx01111xxx
   3177                                                              fcmp.  */
   3178                                                           return 610;
   3179                                                         }
   3180                                                       else
   3181                                                         {
   3182                                                           /* 33222222222211111111110000000000
   3183                                                              10987654321098765432109876543210
   3184                                                              xxx01xxxxx000100xxxxx1xx01111xxx
   3185                                                              fcmpe.  */
   3186                                                           return 611;
   3187                                                         }
   3188                                                     }
   3189                                                   else
   3190                                                     {
   3191                                                       if (((word >> 4) & 0x1) == 0)
   3192                                                         {
   3193                                                           /* 33222222222211111111110000000000
   3194                                                              10987654321098765432109876543210
   3195                                                              xxx10xxxxx000100xxxxx1xx01111xxx
   3196                                                              fcmp.  */
   3197                                                           return 612;
   3198                                                         }
   3199                                                       else
   3200                                                         {
   3201                                                           /* 33222222222211111111110000000000
   3202                                                              10987654321098765432109876543210
   3203                                                              xxx11xxxxx000100xxxxx1xx01111xxx
   3204                                                              fcmpe.  */
   3205                                                           return 613;
   3206                                                         }
   3207                                                     }
   3208                                                 }
   3209                                             }
   3210                                           else
   3211                                             {
   3212                                               if (((word >> 29) & 0x1) == 0)
   3213                                                 {
   3214                                                   if (((word >> 30) & 0x1) == 0)
   3215                                                     {
   3216                                                       /* 33222222222211111111110000000000
   3217                                                          10987654321098765432109876543210
   3218                                                          xxxxxxxxxx000101xxxxx1xx0111x00x
   3219                                                          smlsl.  */
   3220                                                       return 58;
   3221                                                     }
   3222                                                   else
   3223                                                     {
   3224                                                       /* 33222222222211111111110000000000
   3225                                                          10987654321098765432109876543210
   3226                                                          xxxxxxxxxx000101xxxxx1xx0111x01x
   3227                                                          smlsl2.  */
   3228                                                       return 59;
   3229                                                     }
   3230                                                 }
   3231                                               else
   3232                                                 {
   3233                                                   if (((word >> 30) & 0x1) == 0)
   3234                                                     {
   3235                                                       /* 33222222222211111111110000000000
   3236                                                          10987654321098765432109876543210
   3237                                                          xxxxxxxxxx000101xxxxx1xx0111x10x
   3238                                                          umlsl.  */
   3239                                                       return 88;
   3240                                                     }
   3241                                                   else
   3242                                                     {
   3243                                                       /* 33222222222211111111110000000000
   3244                                                          10987654321098765432109876543210
   3245                                                          xxxxxxxxxx000101xxxxx1xx0111x11x
   3246                                                          umlsl2.  */
   3247                                                       return 89;
   3248                                                     }
   3249                                                 }
   3250                                             }
   3251                                         }
   3252                                       else
   3253                                         {
   3254                                           if (((word >> 15) & 0x1) == 0)
   3255                                             {
   3256                                               if (((word >> 29) & 0x1) == 0)
   3257                                                 {
   3258                                                   if (((word >> 30) & 0x1) == 0)
   3259                                                     {
   3260                                                       /* 33222222222211111111110000000000
   3261                                                          10987654321098765432109876543210
   3262                                                          xxxxxxxxxx000110xxxxx1xx0111x00x
   3263                                                          subhn.  */
   3264                                                       return 50;
   3265                                                     }
   3266                                                   else
   3267                                                     {
   3268                                                       /* 33222222222211111111110000000000
   3269                                                          10987654321098765432109876543210
   3270                                                          xxxxxxxxxx000110xxxxx1xx0111x01x
   3271                                                          subhn2.  */
   3272                                                       return 51;
   3273                                                     }
   3274                                                 }
   3275                                               else
   3276                                                 {
   3277                                                   if (((word >> 30) & 0x1) == 0)
   3278                                                     {
   3279                                                       /* 33222222222211111111110000000000
   3280                                                          10987654321098765432109876543210
   3281                                                          xxxxxxxxxx000110xxxxx1xx0111x10x
   3282                                                          rsubhn.  */
   3283                                                       return 82;
   3284                                                     }
   3285                                                   else
   3286                                                     {
   3287                                                       /* 33222222222211111111110000000000
   3288                                                          10987654321098765432109876543210
   3289                                                          xxxxxxxxxx000110xxxxx1xx0111x11x
   3290                                                          rsubhn2.  */
   3291                                                       return 83;
   3292                                                     }
   3293                                                 }
   3294                                             }
   3295                                           else
   3296                                             {
   3297                                               if (((word >> 22) & 0x1) == 0)
   3298                                                 {
   3299                                                   if (((word >> 30) & 0x1) == 0)
   3300                                                     {
   3301                                                       /* 33222222222211111111110000000000
   3302                                                          10987654321098765432109876543210
   3303                                                          xxxxxxxxxx000111xxxxx10x0111xx0x
   3304                                                          pmull.  */
   3305                                                       return 66;
   3306                                                     }
   3307                                                   else
   3308                                                     {
   3309                                                       /* 33222222222211111111110000000000
   3310                                                          10987654321098765432109876543210
   3311                                                          xxxxxxxxxx000111xxxxx10x0111xx1x
   3312                                                          pmull2.  */
   3313                                                       return 68;
   3314                                                     }
   3315                                                 }
   3316                                               else
   3317                                                 {
   3318                                                   if (((word >> 30) & 0x1) == 0)
   3319                                                     {
   3320                                                       /* 33222222222211111111110000000000
   3321                                                          10987654321098765432109876543210
   3322                                                          xxxxxxxxxx000111xxxxx11x0111xx0x
   3323                                                          pmull.  */
   3324                                                       return 67;
   3325                                                     }
   3326                                                   else
   3327                                                     {
   3328                                                       /* 33222222222211111111110000000000
   3329                                                          10987654321098765432109876543210
   3330                                                          xxxxxxxxxx000111xxxxx11x0111xx1x
   3331                                                          pmull2.  */
   3332                                                       return 69;
   3333                                                     }
   3334                                                 }
   3335                                             }
   3336                                         }
   3337                                     }
   3338                                 }
   3339                               else
   3340                                 {
   3341                                   if (((word >> 28) & 0x1) == 0)
   3342                                     {
   3343                                       if (((word >> 13) & 0x1) == 0)
   3344                                         {
   3345                                           if (((word >> 14) & 0x1) == 0)
   3346                                             {
   3347                                               if (((word >> 15) & 0x1) == 0)
   3348                                                 {
   3349                                                   if (((word >> 29) & 0x1) == 0)
   3350                                                     {
   3351                                                       if (((word >> 30) & 0x1) == 0)
   3352                                                         {
   3353                                                           /* 33222222222211111111110000000000
   3354                                                              10987654321098765432109876543210
   3355                                                              xxxxxxxxxx001000xxxxx1xx0111000x
   3356                                                              saddw.  */
   3357                                                           return 40;
   3358                                                         }
   3359                                                       else
   3360                                                         {
   3361                                                           /* 33222222222211111111110000000000
   3362                                                              10987654321098765432109876543210
   3363                                                              xxxxxxxxxx001000xxxxx1xx0111001x
   3364                                                              saddw2.  */
   3365                                                           return 41;
   3366                                                         }
   3367                                                     }
   3368                                                   else
   3369                                                     {
   3370                                                       if (((word >> 30) & 0x1) == 0)
   3371                                                         {
   3372                                                           /* 33222222222211111111110000000000
   3373                                                              10987654321098765432109876543210
   3374                                                              xxxxxxxxxx001000xxxxx1xx0111010x
   3375                                                              uaddw.  */
   3376                                                           return 72;
   3377                                                         }
   3378                                                       else
   3379                                                         {
   3380                                                           /* 33222222222211111111110000000000
   3381                                                              10987654321098765432109876543210
   3382                                                              xxxxxxxxxx001000xxxxx1xx0111011x
   3383                                                              uaddw2.  */
   3384                                                           return 73;
   3385                                                         }
   3386                                                     }
   3387                                                 }
   3388                                               else
   3389                                                 {
   3390                                                   if (((word >> 30) & 0x1) == 0)
   3391                                                     {
   3392                                                       /* 33222222222211111111110000000000
   3393                                                          10987654321098765432109876543210
   3394                                                          xxxxxxxxxx001001xxxxx1xx01110x0x
   3395                                                          sqdmlal.  */
   3396                                                       return 56;
   3397                                                     }
   3398                                                   else
   3399                                                     {
   3400                                                       /* 33222222222211111111110000000000
   3401                                                          10987654321098765432109876543210
   3402                                                          xxxxxxxxxx001001xxxxx1xx01110x1x
   3403                                                          sqdmlal2.  */
   3404                                                       return 57;
   3405                                                     }
   3406                                                 }
   3407                                             }
   3408                                           else
   3409                                             {
   3410                                               if (((word >> 15) & 0x1) == 0)
   3411                                                 {
   3412                                                   if (((word >> 29) & 0x1) == 0)
   3413                                                     {
   3414                                                       if (((word >> 30) & 0x1) == 0)
   3415                                                         {
   3416                                                           /* 33222222222211111111110000000000
   3417                                                              10987654321098765432109876543210
   3418                                                              xxxxxxxxxx001010xxxxx1xx0111000x
   3419                                                              sabal.  */
   3420                                                           return 48;
   3421                                                         }
   3422                                                       else
   3423                                                         {
   3424                                                           /* 33222222222211111111110000000000
   3425                                                              10987654321098765432109876543210
   3426                                                              xxxxxxxxxx001010xxxxx1xx0111001x
   3427                                                              sabal2.  */
   3428                                                           return 49;
   3429                                                         }
   3430                                                     }
   3431                                                   else
   3432                                                     {
   3433                                                       if (((word >> 30) & 0x1) == 0)
   3434                                                         {
   3435                                                           /* 33222222222211111111110000000000
   3436                                                              10987654321098765432109876543210
   3437                                                              xxxxxxxxxx001010xxxxx1xx0111010x
   3438                                                              uabal.  */
   3439                                                           return 80;
   3440                                                         }
   3441                                                       else
   3442                                                         {
   3443                                                           /* 33222222222211111111110000000000
   3444                                                              10987654321098765432109876543210
   3445                                                              xxxxxxxxxx001010xxxxx1xx0111011x
   3446                                                              uabal2.  */
   3447                                                           return 81;
   3448                                                         }
   3449                                                     }
   3450                                                 }
   3451                                               else
   3452                                                 {
   3453                                                   if (((word >> 30) & 0x1) == 0)
   3454                                                     {
   3455                                                       /* 33222222222211111111110000000000
   3456                                                          10987654321098765432109876543210
   3457                                                          xxxxxxxxxx001011xxxxx1xx01110x0x
   3458                                                          sqdmull.  */
   3459                                                       return 64;
   3460                                                     }
   3461                                                   else
   3462                                                     {
   3463                                                       /* 33222222222211111111110000000000
   3464                                                          10987654321098765432109876543210
   3465                                                          xxxxxxxxxx001011xxxxx1xx01110x1x
   3466                                                          sqdmull2.  */
   3467                                                       return 65;
   3468                                                     }
   3469                                                 }
   3470                                             }
   3471                                         }
   3472                                       else
   3473                                         {
   3474                                           if (((word >> 14) & 0x1) == 0)
   3475                                             {
   3476                                               if (((word >> 15) & 0x1) == 0)
   3477                                                 {
   3478                                                   if (((word >> 29) & 0x1) == 0)
   3479                                                     {
   3480                                                       if (((word >> 30) & 0x1) == 0)
   3481                                                         {
   3482                                                           /* 33222222222211111111110000000000
   3483                                                              10987654321098765432109876543210
   3484                                                              xxxxxxxxxx001100xxxxx1xx0111000x
   3485                                                              ssubw.  */
   3486                                                           return 44;
   3487                                                         }
   3488                                                       else
   3489                                                         {
   3490                                                           /* 33222222222211111111110000000000
   3491                                                              10987654321098765432109876543210
   3492                                                              xxxxxxxxxx001100xxxxx1xx0111001x
   3493                                                              ssubw2.  */
   3494                                                           return 45;
   3495                                                         }
   3496                                                     }
   3497                                                   else
   3498                                                     {
   3499                                                       if (((word >> 30) & 0x1) == 0)
   3500                                                         {
   3501                                                           /* 33222222222211111111110000000000
   3502                                                              10987654321098765432109876543210
   3503                                                              xxxxxxxxxx001100xxxxx1xx0111010x
   3504                                                              usubw.  */
   3505                                                           return 76;
   3506                                                         }
   3507                                                       else
   3508                                                         {
   3509                                                           /* 33222222222211111111110000000000
   3510                                                              10987654321098765432109876543210
   3511                                                              xxxxxxxxxx001100xxxxx1xx0111011x
   3512                                                              usubw2.  */
   3513                                                           return 77;
   3514                                                         }
   3515                                                     }
   3516                                                 }
   3517                                               else
   3518                                                 {
   3519                                                   if (((word >> 30) & 0x1) == 0)
   3520                                                     {
   3521                                                       /* 33222222222211111111110000000000
   3522                                                          10987654321098765432109876543210
   3523                                                          xxxxxxxxxx001101xxxxx1xx01110x0x
   3524                                                          sqdmlsl.  */
   3525                                                       return 60;
   3526                                                     }
   3527                                                   else
   3528                                                     {
   3529                                                       /* 33222222222211111111110000000000
   3530                                                          10987654321098765432109876543210
   3531                                                          xxxxxxxxxx001101xxxxx1xx01110x1x
   3532                                                          sqdmlsl2.  */
   3533                                                       return 61;
   3534                                                     }
   3535                                                 }
   3536                                             }
   3537                                           else
   3538                                             {
   3539                                               if (((word >> 29) & 0x1) == 0)
   3540                                                 {
   3541                                                   if (((word >> 30) & 0x1) == 0)
   3542                                                     {
   3543                                                       /* 33222222222211111111110000000000
   3544                                                          10987654321098765432109876543210
   3545                                                          xxxxxxxxxx00111xxxxxx1xx0111000x
   3546                                                          sabdl.  */
   3547                                                       return 52;
   3548                                                     }
   3549                                                   else
   3550                                                     {
   3551                                                       /* 33222222222211111111110000000000
   3552                                                          10987654321098765432109876543210
   3553                                                          xxxxxxxxxx00111xxxxxx1xx0111001x
   3554                                                          sabdl2.  */
   3555                                                       return 53;
   3556                                                     }
   3557                                                 }
   3558                                               else
   3559                                                 {
   3560                                                   if (((word >> 30) & 0x1) == 0)
   3561                                                     {
   3562                                                       /* 33222222222211111111110000000000
   3563                                                          10987654321098765432109876543210
   3564                                                          xxxxxxxxxx00111xxxxxx1xx0111010x
   3565                                                          uabdl.  */
   3566                                                       return 84;
   3567                                                     }
   3568                                                   else
   3569                                                     {
   3570                                                       /* 33222222222211111111110000000000
   3571                                                          10987654321098765432109876543210
   3572                                                          xxxxxxxxxx00111xxxxxx1xx0111011x
   3573                                                          uabdl2.  */
   3574                                                       return 85;
   3575                                                     }
   3576                                                 }
   3577                                             }
   3578                                         }
   3579                                     }
   3580                                   else
   3581                                     {
   3582                                       if (((word >> 30) & 0x1) == 0)
   3583                                         {
   3584                                           /* 33222222222211111111110000000000
   3585                                              10987654321098765432109876543210
   3586                                              xxxxxxxxxx001xxxxxxxx1xx01111x0x
   3587                                              fmov.  */
   3588                                           return 639;
   3589                                         }
   3590                                       else
   3591                                         {
   3592                                           if (((word >> 13) & 0x1) == 0)
   3593                                             {
   3594                                               if (((word >> 14) & 0x1) == 0)
   3595                                                 {
   3596                                                   /* 33222222222211111111110000000000
   3597                                                      10987654321098765432109876543210
   3598                                                      xxxxxxxxxx00100xxxxxx1xx01111x1x
   3599                                                      sqdmlal.  */
   3600                                                   return 343;
   3601                                                 }
   3602                                               else
   3603                                                 {
   3604                                                   /* 33222222222211111111110000000000
   3605                                                      10987654321098765432109876543210
   3606                                                      xxxxxxxxxx00101xxxxxx1xx01111x1x
   3607                                                      sqdmull.  */
   3608                                                   return 345;
   3609                                                 }
   3610                                             }
   3611                                           else
   3612                                             {
   3613                                               /* 33222222222211111111110000000000
   3614                                                  10987654321098765432109876543210
   3615                                                  xxxxxxxxxx0011xxxxxxx1xx01111x1x
   3616                                                  sqdmlsl.  */
   3617                                               return 344;
   3618                                             }
   3619                                         }
   3620                                     }
   3621                                 }
   3622                             }
   3623                           else
   3624                             {
   3625                               if (((word >> 12) & 0x1) == 0)
   3626                                 {
   3627                                   if (((word >> 13) & 0x1) == 0)
   3628                                     {
   3629                                       if (((word >> 14) & 0x1) == 0)
   3630                                         {
   3631                                           if (((word >> 15) & 0x1) == 0)
   3632                                             {
   3633                                               if (((word >> 28) & 0x1) == 0)
   3634                                                 {
   3635                                                   if (((word >> 29) & 0x1) == 0)
   3636                                                     {
   3637                                                       /* 33222222222211111111110000000000
   3638                                                          10987654321098765432109876543210
   3639                                                          xxxxxxxxxx010000xxxxx1xx011100xx
   3640                                                          rev64.  */
   3641                                                       return 144;
   3642                                                     }
   3643                                                   else
   3644                                                     {
   3645                                                       /* 33222222222211111111110000000000
   3646                                                          10987654321098765432109876543210
   3647                                                          xxxxxxxxxx010000xxxxx1xx011101xx
   3648                                                          rev32.  */
   3649                                                       return 180;
   3650                                                     }
   3651                                                 }
   3652                                               else
   3653                                                 {
   3654                                                   if (((word >> 30) & 0x1) == 0)
   3655                                                     {
   3656                                                       /* 33222222222211111111110000000000
   3657                                                          10987654321098765432109876543210
   3658                                                          xxxxxxxxxx010000xxxxx1xx01111x0x
   3659                                                          fmul.  */
   3660                                                       return 626;
   3661                                                     }
   3662                                                   else
   3663                                                     {
   3664                                                       /* 33222222222211111111110000000000
   3665                                                          10987654321098765432109876543210
   3666                                                          xxxxxxxxxx010000xxxxx1xx01111x1x
   3667                                                          sha1h.  */
   3668                                                       return 537;
   3669                                                     }
   3670                                                 }
   3671                                             }
   3672                                           else
   3673                                             {
   3674                                               if (((word >> 28) & 0x1) == 0)
   3675                                                 {
   3676                                                   if (((word >> 16) & 0x1) == 0)
   3677                                                     {
   3678                                                       if (((word >> 29) & 0x1) == 0)
   3679                                                         {
   3680                                                           /* 33222222222211111111110000000000
   3681                                                              10987654321098765432109876543210
   3682                                                              xxxxxxxxxx0100010xxxx1xx011100xx
   3683                                                              cmgt.  */
   3684                                                           return 152;
   3685                                                         }
   3686                                                       else
   3687                                                         {
   3688                                                           /* 33222222222211111111110000000000
   3689                                                              10987654321098765432109876543210
   3690                                                              xxxxxxxxxx0100010xxxx1xx011101xx
   3691                                                              cmge.  */
   3692                                                           return 186;
   3693                                                         }
   3694                                                     }
   3695                                                   else
   3696                                                     {
   3697                                                       if (((word >> 23) & 0x1) == 0)
   3698                                                         {
   3699                                                           if (((word >> 29) & 0x1) == 0)
   3700                                                             {
   3701                                                               /* 33222222222211111111110000000000
   3702                                                                  10987654321098765432109876543210
   3703                                                                  xxxxxxxxxx0100011xxxx1x0011100xx
   3704                                                                  frintn.  */
   3705                                                               return 164;
   3706                                                             }
   3707                                                           else
   3708                                                             {
   3709                                                               /* 33222222222211111111110000000000
   3710                                                                  10987654321098765432109876543210
   3711                                                                  xxxxxxxxxx0100011xxxx1x0011101xx
   3712                                                                  frinta.  */
   3713                                                               return 197;
   3714                                                             }
   3715                                                         }
   3716                                                       else
   3717                                                         {
   3718                                                           /* 33222222222211111111110000000000
   3719                                                              10987654321098765432109876543210
   3720                                                              xxxxxxxxxx0100011xxxx1x101110xxx
   3721                                                              frintp.  */
   3722                                                           return 174;
   3723                                                         }
   3724                                                     }
   3725                                                 }
   3726                                               else
   3727                                                 {
   3728                                                   if (((word >> 29) & 0x1) == 0)
   3729                                                     {
   3730                                                       if (((word >> 30) & 0x1) == 0)
   3731                                                         {
   3732                                                           /* 33222222222211111111110000000000
   3733                                                              10987654321098765432109876543210
   3734                                                              xxxxxxxxxx010001xxxxx1xx0111100x
   3735                                                              fnmul.  */
   3736                                                           return 634;
   3737                                                         }
   3738                                                       else
   3739                                                         {
   3740                                                           /* 33222222222211111111110000000000
   3741                                                              10987654321098765432109876543210
   3742                                                              xxxxxxxxxx010001xxxxx1xx0111101x
   3743                                                              cmgt.  */
   3744                                                           return 397;
   3745                                                         }
   3746                                                     }
   3747                                                   else
   3748                                                     {
   3749                                                       /* 33222222222211111111110000000000
   3750                                                          10987654321098765432109876543210
   3751                                                          xxxxxxxxxx010001xxxxx1xx011111xx
   3752                                                          cmge.  */
   3753                                                       return 415;
   3754                                                     }
   3755                                                 }
   3756                                             }
   3757                                         }
   3758                                       else
   3759                                         {
   3760                                           if (((word >> 15) & 0x1) == 0)
   3761                                             {
   3762                                               if (((word >> 28) & 0x1) == 0)
   3763                                                 {
   3764                                                   if (((word >> 16) & 0x1) == 0)
   3765                                                     {
   3766                                                       if (((word >> 19) & 0x1) == 0)
   3767                                                         {
   3768                                                           if (((word >> 29) & 0x1) == 0)
   3769                                                             {
   3770                                                               /* 33222222222211111111110000000000
   3771                                                                  10987654321098765432109876543210
   3772                                                                  xxxxxxxxxx0100100xx0x1xx011100xx
   3773                                                                  cls.  */
   3774                                                               return 148;
   3775                                                             }
   3776                                                           else
   3777                                                             {
   3778                                                               /* 33222222222211111111110000000000
   3779                                                                  10987654321098765432109876543210
   3780                                                                  xxxxxxxxxx0100100xx0x1xx011101xx
   3781                                                                  clz.  */
   3782                                                               return 183;
   3783                                                             }
   3784                                                         }
   3785                                                       else
   3786                                                         {
   3787                                                           /* 33222222222211111111110000000000
   3788                                                              10987654321098765432109876543210
   3789                                                              xxxxxxxxxx0100100xx1x1xx01110xxx
   3790                                                              aese.  */
   3791                                                           return 533;
   3792                                                         }
   3793                                                     }
   3794                                                   else
   3795                                                     {
   3796                                                       if (((word >> 29) & 0x1) == 0)
   3797                                                         {
   3798                                                           if (((word >> 30) & 0x1) == 0)
   3799                                                             {
   3800                                                               /* 33222222222211111111110000000000
   3801                                                                  10987654321098765432109876543210
   3802                                                                  xxxxxxxxxx0100101xxxx1xx0111000x
   3803                                                                  sqxtn.  */
   3804                                                               return 158;
   3805                                                             }
   3806                                                           else
   3807                                                             {
   3808                                                               /* 33222222222211111111110000000000
   3809                                                                  10987654321098765432109876543210
   3810                                                                  xxxxxxxxxx0100101xxxx1xx0111001x
   3811                                                                  sqxtn2.  */
   3812                                                               return 159;
   3813                                                             }
   3814                                                         }
   3815                                                       else
   3816                                                         {
   3817                                                           if (((word >> 30) & 0x1) == 0)
   3818                                                             {
   3819                                                               /* 33222222222211111111110000000000
   3820                                                                  10987654321098765432109876543210
   3821                                                                  xxxxxxxxxx0100101xxxx1xx0111010x
   3822                                                                  uqxtn.  */
   3823                                                               return 193;
   3824                                                             }
   3825                                                           else
   3826                                                             {
   3827                                                               /* 33222222222211111111110000000000
   3828                                                                  10987654321098765432109876543210
   3829                                                                  xxxxxxxxxx0100101xxxx1xx0111011x
   3830                                                                  uqxtn2.  */
   3831                                                               return 194;
   3832                                                             }
   3833                                                         }
   3834                                                     }
   3835                                                 }
   3836                                               else
   3837                                                 {
   3838                                                   if (((word >> 29) & 0x1) == 0)
   3839                                                     {
   3840                                                       if (((word >> 30) & 0x1) == 0)
   3841                                                         {
   3842                                                           /* 33222222222211111111110000000000
   3843                                                              10987654321098765432109876543210
   3844                                                              xxxxxxxxxx010010xxxxx1xx0111100x
   3845                                                              fmax.  */
   3846                                                           return 630;
   3847                                                         }
   3848                                                       else
   3849                                                         {
   3850                                                           /* 33222222222211111111110000000000
   3851                                                              10987654321098765432109876543210
   3852                                                              xxxxxxxxxx010010xxxxx1xx0111101x
   3853                                                              sqxtn.  */
   3854                                                           return 401;
   3855                                                         }
   3856                                                     }
   3857                                                   else
   3858                                                     {
   3859                                                       /* 33222222222211111111110000000000
   3860                                                          10987654321098765432109876543210
   3861                                                          xxxxxxxxxx010010xxxxx1xx011111xx
   3862                                                          uqxtn.  */
   3863                                                       return 419;
   3864                                                     }
   3865                                                 }
   3866                                             }
   3867                                           else
   3868                                             {
   3869                                               if (((word >> 16) & 0x1) == 0)
   3870                                                 {
   3871                                                   if (((word >> 20) & 0x1) == 0)
   3872                                                     {
   3873                                                       if (((word >> 28) & 0x1) == 0)
   3874                                                         {
   3875                                                           if (((word >> 29) & 0x1) == 0)
   3876                                                             {
   3877                                                               /* 33222222222211111111110000000000
   3878                                                                  10987654321098765432109876543210
   3879                                                                  xxxxxxxxxx0100110xxx01xx011100xx
   3880                                                                  fcmgt.  */
   3881                                                               return 170;
   3882                                                             }
   3883                                                           else
   3884                                                             {
   3885                                                               /* 33222222222211111111110000000000
   3886                                                                  10987654321098765432109876543210
   3887                                                                  xxxxxxxxxx0100110xxx01xx011101xx
   3888                                                                  fcmge.  */
   3889                                                               return 206;
   3890                                                             }
   3891                                                         }
   3892                                                       else
   3893                                                         {
   3894                                                           if (((word >> 29) & 0x1) == 0)
   3895                                                             {
   3896                                                               /* 33222222222211111111110000000000
   3897                                                                  10987654321098765432109876543210
   3898                                                                  xxxxxxxxxx0100110xxx01xx011110xx
   3899                                                                  fcmgt.  */
   3900                                                               return 406;
   3901                                                             }
   3902                                                           else
   3903                                                             {
   3904                                                               /* 33222222222211111111110000000000
   3905                                                                  10987654321098765432109876543210
   3906                                                                  xxxxxxxxxx0100110xxx01xx011111xx
   3907                                                                  fcmge.  */
   3908                                                               return 425;
   3909                                                             }
   3910                                                         }
   3911                                                     }
   3912                                                   else
   3913                                                     {
   3914                                                       if (((word >> 23) & 0x1) == 0)
   3915                                                         {
   3916                                                           if (((word >> 28) & 0x1) == 0)
   3917                                                             {
   3918                                                               /* 33222222222211111111110000000000
   3919                                                                  10987654321098765432109876543210
   3920                                                                  xxxxxxxxxx0100110xxx11x001110xxx
   3921                                                                  fmaxnmv.  */
   3922                                                               return 34;
   3923                                                             }
   3924                                                           else
   3925                                                             {
   3926                                                               /* 33222222222211111111110000000000
   3927                                                                  10987654321098765432109876543210
   3928                                                                  xxxxxxxxxx0100110xxx11x001111xxx
   3929                                                                  fmaxnmp.  */
   3930                                                               return 433;
   3931                                                             }
   3932                                                         }
   3933                                                       else
   3934                                                         {
   3935                                                           if (((word >> 28) & 0x1) == 0)
   3936                                                             {
   3937                                                               /* 33222222222211111111110000000000
   3938                                                                  10987654321098765432109876543210
   3939                                                                  xxxxxxxxxx0100110xxx11x101110xxx
   3940                                                                  fminnmv.  */
   3941                                                               return 36;
   3942                                                             }
   3943                                                           else
   3944                                                             {
   3945                                                               /* 33222222222211111111110000000000
   3946                                                                  10987654321098765432109876543210
   3947                                                                  xxxxxxxxxx0100110xxx11x101111xxx
   3948                                                                  fminnmp.  */
   3949                                                               return 436;
   3950                                                             }
   3951                                                         }
   3952                                                     }
   3953                                                 }
   3954                                               else
   3955                                                 {
   3956                                                   if (((word >> 23) & 0x1) == 0)
   3957                                                     {
   3958                                                       if (((word >> 28) & 0x1) == 0)
   3959                                                         {
   3960                                                           if (((word >> 29) & 0x1) == 0)
   3961                                                             {
   3962                                                               /* 33222222222211111111110000000000
   3963                                                                  10987654321098765432109876543210
   3964                                                                  xxxxxxxxxx0100111xxxx1x0011100xx
   3965                                                                  fcvtas.  */
   3966                                                               return 168;
   3967                                                             }
   3968                                                           else
   3969                                                             {
   3970                                                               /* 33222222222211111111110000000000
   3971                                                                  10987654321098765432109876543210
   3972                                                                  xxxxxxxxxx0100111xxxx1x0011101xx
   3973                                                                  fcvtau.  */
   3974                                                               return 201;
   3975                                                             }
   3976                                                         }
   3977                                                       else
   3978                                                         {
   3979                                                           if (((word >> 29) & 0x1) == 0)
   3980                                                             {
   3981                                                               /* 33222222222211111111110000000000
   3982                                                                  10987654321098765432109876543210
   3983                                                                  xxxxxxxxxx0100111xxxx1x0011110xx
   3984                                                                  fcvtas.  */
   3985                                                               return 404;
   3986                                                             }
   3987                                                           else
   3988                                                             {
   3989                                                               /* 33222222222211111111110000000000
   3990                                                                  10987654321098765432109876543210
   3991                                                                  xxxxxxxxxx0100111xxxx1x0011111xx
   3992                                                                  fcvtau.  */
   3993                                                               return 423;
   3994                                                             }
   3995                                                         }
   3996                                                     }
   3997                                                   else
   3998                                                     {
   3999                                                       if (((word >> 29) & 0x1) == 0)
   4000                                                         {
   4001                                                           /* 33222222222211111111110000000000
   4002                                                              10987654321098765432109876543210
   4003                                                              xxxxxxxxxx0100111xxxx1x10111x0xx
   4004                                                              urecpe.  */
   4005                                                           return 178;
   4006                                                         }
   4007                                                       else
   4008                                                         {
   4009                                                           /* 33222222222211111111110000000000
   4010                                                              10987654321098765432109876543210
   4011                                                              xxxxxxxxxx0100111xxxx1x10111x1xx
   4012                                                              ursqrte.  */
   4013                                                           return 212;
   4014                                                         }
   4015                                                     }
   4016                                                 }
   4017                                             }
   4018                                         }
   4019                                     }
   4020                                   else
   4021                                     {
   4022                                       if (((word >> 14) & 0x1) == 0)
   4023                                         {
   4024                                           if (((word >> 15) & 0x1) == 0)
   4025                                             {
   4026                                               if (((word >> 28) & 0x1) == 0)
   4027                                                 {
   4028                                                   if (((word >> 16) & 0x1) == 0)
   4029                                                     {
   4030                                                       if (((word >> 29) & 0x1) == 0)
   4031                                                         {
   4032                                                           /* 33222222222211111111110000000000
   4033                                                              10987654321098765432109876543210
   4034                                                              xxxxxxxxxx0101000xxxx1xx011100xx
   4035                                                              saddlp.  */
   4036                                                           return 146;
   4037                                                         }
   4038                                                       else
   4039                                                         {
   4040                                                           /* 33222222222211111111110000000000
   4041                                                              10987654321098765432109876543210
   4042                                                              xxxxxxxxxx0101000xxxx1xx011101xx
   4043                                                              uaddlp.  */
   4044                                                           return 181;
   4045                                                         }
   4046                                                     }
   4047                                                   else
   4048                                                     {
   4049                                                       if (((word >> 29) & 0x1) == 0)
   4050                                                         {
   4051                                                           if (((word >> 30) & 0x1) == 0)
   4052                                                             {
   4053                                                               /* 33222222222211111111110000000000
   4054                                                                  10987654321098765432109876543210
   4055                                                                  xxxxxxxxxx0101001xxxx1xx0111000x
   4056                                                                  xtn.  */
   4057                                                               return 156;
   4058                                                             }
   4059                                                           else
   4060                                                             {
   4061                                                               /* 33222222222211111111110000000000
   4062                                                                  10987654321098765432109876543210
   4063                                                                  xxxxxxxxxx0101001xxxx1xx0111001x
   4064                                                                  xtn2.  */
   4065                                                               return 157;
   4066                                                             }
   4067                                                         }
   4068                                                       else
   4069                                                         {
   4070                                                           if (((word >> 30) & 0x1) == 0)
   4071                                                             {
   4072                                                               /* 33222222222211111111110000000000
   4073                                                                  10987654321098765432109876543210
   4074                                                                  xxxxxxxxxx0101001xxxx1xx0111010x
   4075                                                                  sqxtun.  */
   4076                                                               return 189;
   4077                                                             }
   4078                                                           else
   4079                                                             {
   4080                                                               /* 33222222222211111111110000000000
   4081                                                                  10987654321098765432109876543210
   4082                                                                  xxxxxxxxxx0101001xxxx1xx0111011x
   4083                                                                  sqxtun2.  */
   4084                                                               return 190;
   4085                                                             }
   4086                                                         }
   4087                                                     }
   4088                                                 }
   4089                                               else
   4090                                                 {
   4091                                                   if (((word >> 29) & 0x1) == 0)
   4092                                                     {
   4093                                                       if (((word >> 30) & 0x1) == 0)
   4094                                                         {
   4095                                                           /* 33222222222211111111110000000000
   4096                                                              10987654321098765432109876543210
   4097                                                              xxxxxxxxxx010100xxxxx1xx0111100x
   4098                                                              fadd.  */
   4099                                                           return 628;
   4100                                                         }
   4101                                                       else
   4102                                                         {
   4103                                                           /* 33222222222211111111110000000000
   4104                                                              10987654321098765432109876543210
   4105                                                              xxxxxxxxxx010100xxxxx1xx0111101x
   4106                                                              sha256su0.  */
   4107                                                           return 539;
   4108                                                         }
   4109                                                     }
   4110                                                   else
   4111                                                     {
   4112                                                       /* 33222222222211111111110000000000
   4113                                                          10987654321098765432109876543210
   4114                                                          xxxxxxxxxx010100xxxxx1xx011111xx
   4115                                                          sqxtun.  */
   4116                                                       return 418;
   4117                                                     }
   4118                                                 }
   4119                                             }
   4120                                           else
   4121                                             {
   4122                                               if (((word >> 16) & 0x1) == 0)
   4123                                                 {
   4124                                                   if (((word >> 20) & 0x1) == 0)
   4125                                                     {
   4126                                                       if (((word >> 28) & 0x1) == 0)
   4127                                                         {
   4128                                                           /* 33222222222211111111110000000000
   4129                                                              10987654321098765432109876543210
   4130                                                              xxxxxxxxxx0101010xxx01xx01110xxx
   4131                                                              cmlt.  */
   4132                                                           return 154;
   4133                                                         }
   4134                                                       else
   4135                                                         {
   4136                                                           /* 33222222222211111111110000000000
   4137                                                              10987654321098765432109876543210
   4138                                                              xxxxxxxxxx0101010xxx01xx01111xxx
   4139                                                              cmlt.  */
   4140                                                           return 399;
   4141                                                         }
   4142                                                     }
   4143                                                   else
   4144                                                     {
   4145                                                       if (((word >> 29) & 0x1) == 0)
   4146                                                         {
   4147                                                           /* 33222222222211111111110000000000
   4148                                                              10987654321098765432109876543210
   4149                                                              xxxxxxxxxx0101010xxx11xx0111x0xx
   4150                                                              smaxv.  */
   4151                                                           return 28;
   4152                                                         }
   4153                                                       else
   4154                                                         {
   4155                                                           /* 33222222222211111111110000000000
   4156                                                              10987654321098765432109876543210
   4157                                                              xxxxxxxxxx0101010xxx11xx0111x1xx
   4158                                                              umaxv.  */
   4159                                                           return 32;
   4160                                                         }
   4161                                                     }
   4162                                                 }
   4163                                               else
   4164                                                 {
   4165                                                   if (((word >> 20) & 0x1) == 0)
   4166                                                     {
   4167                                                       if (((word >> 23) & 0x1) == 0)
   4168                                                         {
   4169                                                           if (((word >> 28) & 0x1) == 0)
   4170                                                             {
   4171                                                               if (((word >> 29) & 0x1) == 0)
   4172                                                                 {
   4173                                                                   /* 33222222222211111111110000000000
   4174                                                                      10987654321098765432109876543210
   4175                                                                      xxxxxxxxxx0101011xxx01x0011100xx
   4176                                                                      fcvtns.  */
   4177                                                                   return 166;
   4178                                                                 }
   4179                                                               else
   4180                                                                 {
   4181                                                                   /* 33222222222211111111110000000000
   4182                                                                      10987654321098765432109876543210
   4183                                                                      xxxxxxxxxx0101011xxx01x0011101xx
   4184                                                                      fcvtnu.  */
   4185                                                                   return 199;
   4186                                                                 }
   4187                                                             }
   4188                                                           else
   4189                                                             {
   4190                                                               if (((word >> 29) & 0x1) == 0)
   4191                                                                 {
   4192                                                                   /* 33222222222211111111110000000000
   4193                                                                      10987654321098765432109876543210
   4194                                                                      xxxxxxxxxx0101011xxx01x0011110xx
   4195                                                                      fcvtns.  */
   4196                                                                   return 402;
   4197                                                                 }
   4198                                                               else
   4199                                                                 {
   4200                                                                   /* 33222222222211111111110000000000
   4201                                                                      10987654321098765432109876543210
   4202                                                                      xxxxxxxxxx0101011xxx01x0011111xx
   4203                                                                      fcvtnu.  */
   4204                                                                   return 421;
   4205                                                                 }
   4206                                                             }
   4207                                                         }
   4208                                                       else
   4209                                                         {
   4210                                                           if (((word >> 28) & 0x1) == 0)
   4211                                                             {
   4212                                                               if (((word >> 29) & 0x1) == 0)
   4213                                                                 {
   4214                                                                   /* 33222222222211111111110000000000
   4215                                                                      10987654321098765432109876543210
   4216                                                                      xxxxxxxxxx0101011xxx01x1011100xx
   4217                                                                      fcvtps.  */
   4218                                                                   return 176;
   4219                                                                 }
   4220                                                               else
   4221                                                                 {
   4222                                                                   /* 33222222222211111111110000000000
   4223                                                                      10987654321098765432109876543210
   4224                                                                      xxxxxxxxxx0101011xxx01x1011101xx
   4225                                                                      fcvtpu.  */
   4226                                                                   return 210;
   4227                                                                 }
   4228                                                             }
   4229                                                           else
   4230                                                             {
   4231                                                               if (((word >> 29) & 0x1) == 0)
   4232                                                                 {
   4233                                                                   /* 33222222222211111111110000000000
   4234                                                                      10987654321098765432109876543210
   4235                                                                      xxxxxxxxxx0101011xxx01x1011110xx
   4236                                                                      fcvtps.  */
   4237                                                                   return 409;
   4238                                                                 }
   4239                                                               else
   4240                                                                 {
   4241                                                                   /* 33222222222211111111110000000000
   4242                                                                      10987654321098765432109876543210
   4243                                                                      xxxxxxxxxx0101011xxx01x1011111xx
   4244                                                                      fcvtpu.  */
   4245                                                                   return 427;
   4246                                                                 }
   4247                                                             }
   4248                                                         }
   4249                                                     }
   4250                                                   else
   4251                                                     {
   4252                                                       if (((word >> 29) & 0x1) == 0)
   4253                                                         {
   4254                                                           /* 33222222222211111111110000000000
   4255                                                              10987654321098765432109876543210
   4256                                                              xxxxxxxxxx0101011xxx11xx0111x0xx
   4257                                                              sminv.  */
   4258                                                           return 29;
   4259                                                         }
   4260                                                       else
   4261                                                         {
   4262                                                           /* 33222222222211111111110000000000
   4263                                                              10987654321098765432109876543210
   4264                                                              xxxxxxxxxx0101011xxx11xx0111x1xx
   4265                                                              uminv.  */
   4266                                                           return 33;
   4267                                                         }
   4268                                                     }
   4269                                                 }
   4270                                             }
   4271                                         }
   4272                                       else
   4273                                         {
   4274                                           if (((word >> 15) & 0x1) == 0)
   4275                                             {
   4276                                               if (((word >> 28) & 0x1) == 0)
   4277                                                 {
   4278                                                   if (((word >> 16) & 0x1) == 0)
   4279                                                     {
   4280                                                       if (((word >> 19) & 0x1) == 0)
   4281                                                         {
   4282                                                           if (((word >> 29) & 0x1) == 0)
   4283                                                             {
   4284                                                               /* 33222222222211111111110000000000
   4285                                                                  10987654321098765432109876543210
   4286                                                                  xxxxxxxxxx0101100xx0x1xx011100xx
   4287                                                                  sadalp.  */
   4288                                                               return 150;
   4289                                                             }
   4290                                                           else
   4291                                                             {
   4292                                                               /* 33222222222211111111110000000000
   4293                                                                  10987654321098765432109876543210
   4294                                                                  xxxxxxxxxx0101100xx0x1xx011101xx
   4295                                                                  uadalp.  */
   4296                                                               return 184;
   4297                                                             }
   4298                                                         }
   4299                                                       else
   4300                                                         {
   4301                                                           /* 33222222222211111111110000000000
   4302                                                              10987654321098765432109876543210
   4303                                                              xxxxxxxxxx0101100xx1x1xx01110xxx
   4304                                                              aesmc.  */
   4305                                                           return 535;
   4306                                                         }
   4307                                                     }
   4308                                                   else
   4309                                                     {
   4310                                                       if (((word >> 29) & 0x1) == 0)
   4311                                                         {
   4312                                                           if (((word >> 30) & 0x1) == 0)
   4313                                                             {
   4314                                                               /* 33222222222211111111110000000000
   4315                                                                  10987654321098765432109876543210
   4316                                                                  xxxxxxxxxx0101101xxxx1xx0111000x
   4317                                                                  fcvtn.  */
   4318                                                               return 160;
   4319                                                             }
   4320                                                           else
   4321                                                             {
   4322                                                               /* 33222222222211111111110000000000
   4323                                                                  10987654321098765432109876543210
   4324                                                                  xxxxxxxxxx0101101xxxx1xx0111001x
   4325                                                                  fcvtn2.  */
   4326                                                               return 161;
   4327                                                             }
   4328                                                         }
   4329                                                       else
   4330                                                         {
   4331                                                           if (((word >> 30) & 0x1) == 0)
   4332                                                             {
   4333                                                               /* 33222222222211111111110000000000
   4334                                                                  10987654321098765432109876543210
   4335                                                                  xxxxxxxxxx0101101xxxx1xx0111010x
   4336                                                                  fcvtxn.  */
   4337                                                               return 195;
   4338                                                             }
   4339                                                           else
   4340                                                             {
   4341                                                               /* 33222222222211111111110000000000
   4342                                                                  10987654321098765432109876543210
   4343                                                                  xxxxxxxxxx0101101xxxx1xx0111011x
   4344                                                                  fcvtxn2.  */
   4345                                                               return 196;
   4346                                                             }
   4347                                                         }
   4348                                                     }
   4349                                                 }
   4350                                               else
   4351                                                 {
   4352                                                   if (((word >> 29) & 0x1) == 0)
   4353                                                     {
   4354                                                       /* 33222222222211111111110000000000
   4355                                                          10987654321098765432109876543210
   4356                                                          xxxxxxxxxx010110xxxxx1xx011110xx
   4357                                                          fmaxnm.  */
   4358                                                       return 632;
   4359                                                     }
   4360                                                   else
   4361                                                     {
   4362                                                       /* 33222222222211111111110000000000
   4363                                                          10987654321098765432109876543210
   4364                                                          xxxxxxxxxx010110xxxxx1xx011111xx
   4365                                                          fcvtxn.  */
   4366                                                       return 420;
   4367                                                     }
   4368                                                 }
   4369                                             }
   4370                                           else
   4371                                             {
   4372                                               if (((word >> 28) & 0x1) == 0)
   4373                                                 {
   4374                                                   /* 33222222222211111111110000000000
   4375                                                      10987654321098765432109876543210
   4376                                                      xxxxxxxxxx010111xxxxx1xx01110xxx
   4377                                                      fcmlt.  */
   4378                                                   return 172;
   4379                                                 }
   4380                                               else
   4381                                                 {
   4382                                                   /* 33222222222211111111110000000000
   4383                                                      10987654321098765432109876543210
   4384                                                      xxxxxxxxxx010111xxxxx1xx01111xxx
   4385                                                      fcmlt.  */
   4386                                                   return 408;
   4387                                                 }
   4388                                             }
   4389                                         }
   4390                                     }
   4391                                 }
   4392                               else
   4393                                 {
   4394                                   if (((word >> 13) & 0x1) == 0)
   4395                                     {
   4396                                       if (((word >> 14) & 0x1) == 0)
   4397                                         {
   4398                                           if (((word >> 15) & 0x1) == 0)
   4399                                             {
   4400                                               if (((word >> 28) & 0x1) == 0)
   4401                                                 {
   4402                                                   /* 33222222222211111111110000000000
   4403                                                      10987654321098765432109876543210
   4404                                                      xxxxxxxxxx011000xxxxx1xx01110xxx
   4405                                                      rev16.  */
   4406                                                   return 145;
   4407                                                 }
   4408                                               else
   4409                                                 {
   4410                                                   if (((word >> 30) & 0x1) == 0)
   4411                                                     {
   4412                                                       /* 33222222222211111111110000000000
   4413                                                          10987654321098765432109876543210
   4414                                                          xxxxxxxxxx011000xxxxx1xx01111x0x
   4415                                                          fdiv.  */
   4416                                                       return 627;
   4417                                                     }
   4418                                                   else
   4419                                                     {
   4420                                                       /* 33222222222211111111110000000000
   4421                                                          10987654321098765432109876543210
   4422                                                          xxxxxxxxxx011000xxxxx1xx01111x1x
   4423                                                          sha1su1.  */
   4424                                                       return 538;
   4425                                                     }
   4426                                                 }
   4427                                             }
   4428                                           else
   4429                                             {
   4430                                               if (((word >> 16) & 0x1) == 0)
   4431                                                 {
   4432                                                   if (((word >> 28) & 0x1) == 0)
   4433                                                     {
   4434                                                       if (((word >> 29) & 0x1) == 0)
   4435                                                         {
   4436                                                           /* 33222222222211111111110000000000
   4437                                                              10987654321098765432109876543210
   4438                                                              xxxxxxxxxx0110010xxxx1xx011100xx
   4439                                                              cmeq.  */
   4440                                                           return 153;
   4441                                                         }
   4442                                                       else
   4443                                                         {
   4444                                                           /* 33222222222211111111110000000000
   4445                                                              10987654321098765432109876543210
   4446                                                              xxxxxxxxxx0110010xxxx1xx011101xx
   4447                                                              cmle.  */
   4448                                                           return 187;
   4449                                                         }
   4450                                                     }
   4451                                                   else
   4452                                                     {
   4453                                                       if (((word >> 29) & 0x1) == 0)
   4454                                                         {
   4455                                                           /* 33222222222211111111110000000000
   4456                                                              10987654321098765432109876543210
   4457                                                              xxxxxxxxxx0110010xxxx1xx011110xx
   4458                                                              cmeq.  */
   4459                                                           return 398;
   4460                                                         }
   4461                                                       else
   4462                                                         {
   4463                                                           /* 33222222222211111111110000000000
   4464                                                              10987654321098765432109876543210
   4465                                                              xxxxxxxxxx0110010xxxx1xx011111xx
   4466                                                              cmle.  */
   4467                                                           return 416;
   4468                                                         }
   4469                                                     }
   4470                                                 }
   4471                                               else
   4472                                                 {
   4473                                                   if (((word >> 23) & 0x1) == 0)
   4474                                                     {
   4475                                                       if (((word >> 29) & 0x1) == 0)
   4476                                                         {
   4477                                                           /* 33222222222211111111110000000000
   4478                                                              10987654321098765432109876543210
   4479                                                              xxxxxxxxxx0110011xxxx1x00111x0xx
   4480                                                              frintm.  */
   4481                                                           return 165;
   4482                                                         }
   4483                                                       else
   4484                                                         {
   4485                                                           /* 33222222222211111111110000000000
   4486                                                              10987654321098765432109876543210
   4487                                                              xxxxxxxxxx0110011xxxx1x00111x1xx
   4488                                                              frintx.  */
   4489                                                           return 198;
   4490                                                         }
   4491                                                     }
   4492                                                   else
   4493                                                     {
   4494                                                       if (((word >> 29) & 0x1) == 0)
   4495                                                         {
   4496                                                           /* 33222222222211111111110000000000
   4497                                                              10987654321098765432109876543210
   4498                                                              xxxxxxxxxx0110011xxxx1x10111x0xx
   4499                                                              frintz.  */
   4500                                                           return 175;
   4501                                                         }
   4502                                                       else
   4503                                                         {
   4504                                                           /* 33222222222211111111110000000000
   4505                                                              10987654321098765432109876543210
   4506                                                              xxxxxxxxxx0110011xxxx1x10111x1xx
   4507                                                              frinti.  */
   4508                                                           return 209;
   4509                                                         }
   4510                                                     }
   4511                                                 }
   4512                                             }
   4513                                         }
   4514                                       else
   4515                                         {
   4516                                           if (((word >> 15) & 0x1) == 0)
   4517                                             {
   4518                                               if (((word >> 28) & 0x1) == 0)
   4519                                                 {
   4520                                                   if (((word >> 19) & 0x1) == 0)
   4521                                                     {
   4522                                                       if (((word >> 29) & 0x1) == 0)
   4523                                                         {
   4524                                                           /* 33222222222211111111110000000000
   4525                                                              10987654321098765432109876543210
   4526                                                              xxxxxxxxxx011010xxx0x1xx011100xx
   4527                                                              cnt.  */
   4528                                                           return 149;
   4529                                                         }
   4530                                                       else
   4531                                                         {
   4532                                                           if (((word >> 22) & 0x1) == 0)
   4533                                                             {
   4534                                                               /* 33222222222211111111110000000000
   4535                                                                  10987654321098765432109876543210
   4536                                                                  xxxxxxxxxx011010xxx0x10x011101xx
   4537                                                                  not.  */
   4538                                                               return 203;
   4539                                                             }
   4540                                                           else
   4541                                                             {
   4542                                                               /* 33222222222211111111110000000000
   4543                                                                  10987654321098765432109876543210
   4544                                                                  xxxxxxxxxx011010xxx0x11x011101xx
   4545                                                                  rbit.  */
   4546                                                               return 205;
   4547                                                             }
   4548                                                         }
   4549                                                     }
   4550                                                   else
   4551                                                     {
   4552                                                       /* 33222222222211111111110000000000
   4553                                                          10987654321098765432109876543210
   4554                                                          xxxxxxxxxx011010xxx1x1xx01110xxx
   4555                                                          aesd.  */
   4556                                                       return 534;
   4557                                                     }
   4558                                                 }
   4559                                               else
   4560                                                 {
   4561                                                   /* 33222222222211111111110000000000
   4562                                                      10987654321098765432109876543210
   4563                                                      xxxxxxxxxx011010xxxxx1xx01111xxx
   4564                                                      fmin.  */
   4565                                                   return 631;
   4566                                                 }
   4567                                             }
   4568                                           else
   4569                                             {
   4570                                               if (((word >> 16) & 0x1) == 0)
   4571                                                 {
   4572                                                   if (((word >> 20) & 0x1) == 0)
   4573                                                     {
   4574                                                       if (((word >> 28) & 0x1) == 0)
   4575                                                         {
   4576                                                           if (((word >> 29) & 0x1) == 0)
   4577                                                             {
   4578                                                               /* 33222222222211111111110000000000
   4579                                                                  10987654321098765432109876543210
   4580                                                                  xxxxxxxxxx0110110xxx01xx011100xx
   4581                                                                  fcmeq.  */
   4582                                                               return 171;
   4583                                                             }
   4584                                                           else
   4585                                                             {
   4586                                                               /* 33222222222211111111110000000000
   4587                                                                  10987654321098765432109876543210
   4588                                                                  xxxxxxxxxx0110110xxx01xx011101xx
   4589                                                                  fcmle.  */
   4590                                                               return 207;
   4591                                                             }
   4592                                                         }
   4593                                                       else
   4594                                                         {
   4595                                                           if (((word >> 29) & 0x1) == 0)
   4596                                                             {
   4597                                                               /* 33222222222211111111110000000000
   4598                                                                  10987654321098765432109876543210
   4599                                                                  xxxxxxxxxx0110110xxx01xx011110xx
   4600                                                                  fcmeq.  */
   4601                                                               return 407;
   4602                                                             }
   4603                                                           else
   4604                                                             {
   4605                                                               /* 33222222222211111111110000000000
   4606                                                                  10987654321098765432109876543210
   4607                                                                  xxxxxxxxxx0110110xxx01xx011111xx
   4608                                                                  fcmle.  */
   4609                                                               return 426;
   4610                                                             }
   4611                                                         }
   4612                                                     }
   4613                                                   else
   4614                                                     {
   4615                                                       /* 33222222222211111111110000000000
   4616                                                          10987654321098765432109876543210
   4617                                                          xxxxxxxxxx0110110xxx11xx0111xxxx
   4618                                                          faddp.  */
   4619                                                       return 434;
   4620                                                     }
   4621                                                 }
   4622                                               else
   4623                                                 {
   4624                                                   if (((word >> 23) & 0x1) == 0)
   4625                                                     {
   4626                                                       if (((word >> 28) & 0x1) == 0)
   4627                                                         {
   4628                                                           if (((word >> 29) & 0x1) == 0)
   4629                                                             {
   4630                                                               /* 33222222222211111111110000000000
   4631                                                                  10987654321098765432109876543210
   4632                                                                  xxxxxxxxxx0110111xxxx1x0011100xx
   4633                                                                  scvtf.  */
   4634                                                               return 169;
   4635                                                             }
   4636                                                           else
   4637                                                             {
   4638                                                               /* 33222222222211111111110000000000
   4639                                                                  10987654321098765432109876543210
   4640                                                                  xxxxxxxxxx0110111xxxx1x0011101xx
   4641                                                                  ucvtf.  */
   4642                                                               return 202;
   4643                                                             }
   4644                                                         }
   4645                                                       else
   4646                                                         {
   4647                                                           if (((word >> 29) & 0x1) == 0)
   4648                                                             {
   4649                                                               /* 33222222222211111111110000000000
   4650                                                                  10987654321098765432109876543210
   4651                                                                  xxxxxxxxxx0110111xxxx1x0011110xx
   4652                                                                  scvtf.  */
   4653                                                               return 405;
   4654                                                             }
   4655                                                           else
   4656                                                             {
   4657                                                               /* 33222222222211111111110000000000
   4658                                                                  10987654321098765432109876543210
   4659                                                                  xxxxxxxxxx0110111xxxx1x0011111xx
   4660                                                                  ucvtf.  */
   4661                                                               return 424;
   4662                                                             }
   4663                                                         }
   4664                                                     }
   4665                                                   else
   4666                                                     {
   4667                                                       if (((word >> 28) & 0x1) == 0)
   4668                                                         {
   4669                                                           if (((word >> 29) & 0x1) == 0)
   4670                                                             {
   4671                                                               /* 33222222222211111111110000000000
   4672                                                                  10987654321098765432109876543210
   4673                                                                  xxxxxxxxxx0110111xxxx1x1011100xx
   4674                                                                  frecpe.  */
   4675                                                               return 179;
   4676                                                             }
   4677                                                           else
   4678                                                             {
   4679                                                               /* 33222222222211111111110000000000
   4680                                                                  10987654321098765432109876543210
   4681                                                                  xxxxxxxxxx0110111xxxx1x1011101xx
   4682                                                                  frsqrte.  */
   4683                                                               return 213;
   4684                                                             }
   4685                                                         }
   4686                                                       else
   4687                                                         {
   4688                                                           if (((word >> 29) & 0x1) == 0)
   4689                                                             {
   4690                                                               /* 33222222222211111111110000000000
   4691                                                                  10987654321098765432109876543210
   4692                                                                  xxxxxxxxxx0110111xxxx1x1011110xx
   4693                                                                  frecpe.  */
   4694                                                               return 411;
   4695                                                             }
   4696                                                           else
   4697                                                             {
   4698                                                               /* 33222222222211111111110000000000
   4699                                                                  10987654321098765432109876543210
   4700                                                                  xxxxxxxxxx0110111xxxx1x1011111xx
   4701                                                                  frsqrte.  */
   4702                                                               return 429;
   4703                                                             }
   4704                                                         }
   4705                                                     }
   4706                                                 }
   4707                                             }
   4708                                         }
   4709                                     }
   4710                                   else
   4711                                     {
   4712                                       if (((word >> 14) & 0x1) == 0)
   4713                                         {
   4714                                           if (((word >> 15) & 0x1) == 0)
   4715                                             {
   4716                                               if (((word >> 28) & 0x1) == 0)
   4717                                                 {
   4718                                                   if (((word >> 16) & 0x1) == 0)
   4719                                                     {
   4720                                                       if (((word >> 20) & 0x1) == 0)
   4721                                                         {
   4722                                                           if (((word >> 29) & 0x1) == 0)
   4723                                                             {
   4724                                                               /* 33222222222211111111110000000000
   4725                                                                  10987654321098765432109876543210
   4726                                                                  xxxxxxxxxx0111000xxx01xx011100xx
   4727                                                                  suqadd.  */
   4728                                                               return 147;
   4729                                                             }
   4730                                                           else
   4731                                                             {
   4732                                                               /* 33222222222211111111110000000000
   4733                                                                  10987654321098765432109876543210
   4734                                                                  xxxxxxxxxx0111000xxx01xx011101xx
   4735                                                                  usqadd.  */
   4736                                                               return 182;
   4737                                                             }
   4738                                                         }
   4739                                                       else
   4740                                                         {
   4741                                                           if (((word >> 29) & 0x1) == 0)
   4742                                                             {
   4743                                                               /* 33222222222211111111110000000000
   4744                                                                  10987654321098765432109876543210
   4745                                                                  xxxxxxxxxx0111000xxx11xx011100xx
   4746                                                                  saddlv.  */
   4747                                                               return 27;
   4748                                                             }
   4749                                                           else
   4750                                                             {
   4751                                                               /* 33222222222211111111110000000000
   4752                                                                  10987654321098765432109876543210
   4753                                                                  xxxxxxxxxx0111000xxx11xx011101xx
   4754                                                                  uaddlv.  */
   4755                                                               return 31;
   4756                                                             }
   4757                                                         }
   4758                                                     }
   4759                                                   else
   4760                                                     {
   4761                                                       if (((word >> 30) & 0x1) == 0)
   4762                                                         {
   4763                                                           /* 33222222222211111111110000000000
   4764                                                              10987654321098765432109876543210
   4765                                                              xxxxxxxxxx0111001xxxx1xx01110x0x
   4766                                                              shll.  */
   4767                                                           return 191;
   4768                                                         }
   4769                                                       else
   4770                                                         {
   4771                                                           /* 33222222222211111111110000000000
   4772                                                              10987654321098765432109876543210
   4773                                                              xxxxxxxxxx0111001xxxx1xx01110x1x
   4774                                                              shll2.  */
   4775                                                           return 192;
   4776                                                         }
   4777                                                     }
   4778                                                 }
   4779                                               else
   4780                                                 {
   4781                                                   if (((word >> 29) & 0x1) == 0)
   4782                                                     {
   4783                                                       if (((word >> 30) & 0x1) == 0)
   4784                                                         {
   4785                                                           /* 33222222222211111111110000000000
   4786                                                              10987654321098765432109876543210
   4787                                                              xxxxxxxxxx011100xxxxx1xx0111100x
   4788                                                              fsub.  */
   4789                                                           return 629;
   4790                                                         }
   4791                                                       else
   4792                                                         {
   4793                                                           /* 33222222222211111111110000000000
   4794                                                              10987654321098765432109876543210
   4795                                                              xxxxxxxxxx011100xxxxx1xx0111101x
   4796                                                              suqadd.  */
   4797                                                           return 395;
   4798                                                         }
   4799                                                     }
   4800                                                   else
   4801                                                     {
   4802                                                       /* 33222222222211111111110000000000
   4803                                                          10987654321098765432109876543210
   4804                                                          xxxxxxxxxx011100xxxxx1xx011111xx
   4805                                                          usqadd.  */
   4806                                                       return 413;
   4807                                                     }
   4808                                                 }
   4809                                             }
   4810                                           else
   4811                                             {
   4812                                               if (((word >> 16) & 0x1) == 0)
   4813                                                 {
   4814                                                   if (((word >> 28) & 0x1) == 0)
   4815                                                     {
   4816                                                       if (((word >> 29) & 0x1) == 0)
   4817                                                         {
   4818                                                           /* 33222222222211111111110000000000
   4819                                                              10987654321098765432109876543210
   4820                                                              xxxxxxxxxx0111010xxxx1xx011100xx
   4821                                                              abs.  */
   4822                                                           return 155;
   4823                                                         }
   4824                                                       else
   4825                                                         {
   4826                                                           /* 33222222222211111111110000000000
   4827                                                              10987654321098765432109876543210
   4828                                                              xxxxxxxxxx0111010xxxx1xx011101xx
   4829                                                              neg.  */
   4830                                                           return 188;
   4831                                                         }
   4832                                                     }
   4833                                                   else
   4834                                                     {
   4835                                                       if (((word >> 29) & 0x1) == 0)
   4836                                                         {
   4837                                                           /* 33222222222211111111110000000000
   4838                                                              10987654321098765432109876543210
   4839                                                              xxxxxxxxxx0111010xxxx1xx011110xx
   4840                                                              abs.  */
   4841                                                           return 400;
   4842                                                         }
   4843                                                       else
   4844                                                         {
   4845                                                           /* 33222222222211111111110000000000
   4846                                                              10987654321098765432109876543210
   4847                                                              xxxxxxxxxx0111010xxxx1xx011111xx
   4848                                                              neg.  */
   4849                                                           return 417;
   4850                                                         }
   4851                                                     }
   4852                                                 }
   4853                                               else
   4854                                                 {
   4855                                                   if (((word >> 20) & 0x1) == 0)
   4856                                                     {
   4857                                                       if (((word >> 23) & 0x1) == 0)
   4858                                                         {
   4859                                                           if (((word >> 28) & 0x1) == 0)
   4860                                                             {
   4861                                                               if (((word >> 29) & 0x1) == 0)
   4862                                                                 {
   4863                                                                   /* 33222222222211111111110000000000
   4864                                                                      10987654321098765432109876543210
   4865                                                                      xxxxxxxxxx0111011xxx01x0011100xx
   4866                                                                      fcvtms.  */
   4867                                                                   return 167;
   4868                                                                 }
   4869                                                               else
   4870                                                                 {
   4871                                                                   /* 33222222222211111111110000000000
   4872                                                                      10987654321098765432109876543210
   4873                                                                      xxxxxxxxxx0111011xxx01x0011101xx
   4874                                                                      fcvtmu.  */
   4875                                                                   return 200;
   4876                                                                 }
   4877                                                             }
   4878                                                           else
   4879                                                             {
   4880                                                               if (((word >> 29) & 0x1) == 0)
   4881                                                                 {
   4882                                                                   /* 33222222222211111111110000000000
   4883                                                                      10987654321098765432109876543210
   4884                                                                      xxxxxxxxxx0111011xxx01x0011110xx
   4885                                                                      fcvtms.  */
   4886                                                                   return 403;
   4887                                                                 }
   4888                                                               else
   4889                                                                 {
   4890                                                                   /* 33222222222211111111110000000000
   4891                                                                      10987654321098765432109876543210
   4892                                                                      xxxxxxxxxx0111011xxx01x0011111xx
   4893                                                                      fcvtmu.  */
   4894                                                                   return 422;
   4895                                                                 }
   4896                                                             }
   4897                                                         }
   4898                                                       else
   4899                                                         {
   4900                                                           if (((word >> 28) & 0x1) == 0)
   4901                                                             {
   4902                                                               if (((word >> 29) & 0x1) == 0)
   4903                                                                 {
   4904                                                                   /* 33222222222211111111110000000000
   4905                                                                      10987654321098765432109876543210
   4906                                                                      xxxxxxxxxx0111011xxx01x1011100xx
   4907                                                                      fcvtzs.  */
   4908                                                                   return 177;
   4909                                                                 }
   4910                                                               else
   4911                                                                 {
   4912                                                                   /* 33222222222211111111110000000000
   4913                                                                      10987654321098765432109876543210
   4914                                                                      xxxxxxxxxx0111011xxx01x1011101xx
   4915                                                                      fcvtzu.  */
   4916                                                                   return 211;
   4917                                                                 }
   4918                                                             }
   4919                                                           else
   4920                                                             {
   4921                                                               if (((word >> 29) & 0x1) == 0)
   4922                                                                 {
   4923                                                                   /* 33222222222211111111110000000000
   4924                                                                      10987654321098765432109876543210
   4925                                                                      xxxxxxxxxx0111011xxx01x1011110xx
   4926                                                                      fcvtzs.  */
   4927                                                                   return 410;
   4928                                                                 }
   4929                                                               else
   4930                                                                 {
   4931                                                                   /* 33222222222211111111110000000000
   4932                                                                      10987654321098765432109876543210
   4933                                                                      xxxxxxxxxx0111011xxx01x1011111xx
   4934                                                                      fcvtzu.  */
   4935                                                                   return 428;
   4936                                                                 }
   4937                                                             }
   4938                                                         }
   4939                                                     }
   4940                                                   else
   4941                                                     {
   4942                                                       if (((word >> 28) & 0x1) == 0)
   4943                                                         {
   4944                                                           /* 33222222222211111111110000000000
   4945                                                              10987654321098765432109876543210
   4946                                                              xxxxxxxxxx0111011xxx11xx01110xxx
   4947                                                              addv.  */
   4948                                                           return 30;
   4949                                                         }
   4950                                                       else
   4951                                                         {
   4952                                                           /* 33222222222211111111110000000000
   4953                                                              10987654321098765432109876543210
   4954                                                              xxxxxxxxxx0111011xxx11xx01111xxx
   4955                                                              addp.  */
   4956                                                           return 432;
   4957                                                         }
   4958                                                     }
   4959                                                 }
   4960                                             }
   4961                                         }
   4962                                       else
   4963                                         {
   4964                                           if (((word >> 15) & 0x1) == 0)
   4965                                             {
   4966                                               if (((word >> 28) & 0x1) == 0)
   4967                                                 {
   4968                                                   if (((word >> 16) & 0x1) == 0)
   4969                                                     {
   4970                                                       if (((word >> 19) & 0x1) == 0)
   4971                                                         {
   4972                                                           if (((word >> 29) & 0x1) == 0)
   4973                                                             {
   4974                                                               /* 33222222222211111111110000000000
   4975                                                                  10987654321098765432109876543210
   4976                                                                  xxxxxxxxxx0111100xx0x1xx011100xx
   4977                                                                  sqabs.  */
   4978                                                               return 151;
   4979                                                             }
   4980                                                           else
   4981                                                             {
   4982                                                               /* 33222222222211111111110000000000
   4983                                                                  10987654321098765432109876543210
   4984                                                                  xxxxxxxxxx0111100xx0x1xx011101xx
   4985                                                                  sqneg.  */
   4986                                                               return 185;
   4987                                                             }
   4988                                                         }
   4989                                                       else
   4990                                                         {
   4991                                                           /* 33222222222211111111110000000000
   4992                                                              10987654321098765432109876543210
   4993                                                              xxxxxxxxxx0111100xx1x1xx01110xxx
   4994                                                              aesimc.  */
   4995                                                           return 536;
   4996                                                         }
   4997                                                     }
   4998                                                   else
   4999                                                     {
   5000                                                       if (((word >> 30) & 0x1) == 0)
   5001                                                         {
   5002                                                           /* 33222222222211111111110000000000
   5003                                                              10987654321098765432109876543210
   5004                                                              xxxxxxxxxx0111101xxxx1xx01110x0x
   5005                                                              fcvtl.  */
   5006                                                           return 162;
   5007                                                         }
   5008                                                       else
   5009                                                         {
   5010                                                           /* 33222222222211111111110000000000
   5011                                                              10987654321098765432109876543210
   5012                                                              xxxxxxxxxx0111101xxxx1xx01110x1x
   5013                                                              fcvtl2.  */
   5014                                                           return 163;
   5015                                                         }
   5016                                                     }
   5017                                                 }
   5018                                               else
   5019                                                 {
   5020                                                   if (((word >> 29) & 0x1) == 0)
   5021                                                     {
   5022                                                       if (((word >> 30) & 0x1) == 0)
   5023                                                         {
   5024                                                           /* 33222222222211111111110000000000
   5025                                                              10987654321098765432109876543210
   5026                                                              xxxxxxxxxx011110xxxxx1xx0111100x
   5027                                                              fminnm.  */
   5028                                                           return 633;
   5029                                                         }
   5030                                                       else
   5031                                                         {
   5032                                                           /* 33222222222211111111110000000000
   5033                                                              10987654321098765432109876543210
   5034                                                              xxxxxxxxxx011110xxxxx1xx0111101x
   5035                                                              sqabs.  */
   5036                                                           return 396;
   5037                                                         }
   5038                                                     }
   5039                                                   else
   5040                                                     {
   5041                                                       /* 33222222222211111111110000000000
   5042                                                          10987654321098765432109876543210
   5043                                                          xxxxxxxxxx011110xxxxx1xx011111xx
   5044                                                          sqneg.  */
   5045                                                       return 414;
   5046                                                     }
   5047                                                 }
   5048                                             }
   5049                                           else
   5050                                             {
   5051                                               if (((word >> 16) & 0x1) == 0)
   5052                                                 {
   5053                                                   if (((word >> 20) & 0x1) == 0)
   5054                                                     {
   5055                                                       if (((word >> 29) & 0x1) == 0)
   5056                                                         {
   5057                                                           /* 33222222222211111111110000000000
   5058                                                              10987654321098765432109876543210
   5059                                                              xxxxxxxxxx0111110xxx01xx0111x0xx
   5060                                                              fabs.  */
   5061                                                           return 173;
   5062                                                         }
   5063                                                       else
   5064                                                         {
   5065                                                           /* 33222222222211111111110000000000
   5066                                                              10987654321098765432109876543210
   5067                                                              xxxxxxxxxx0111110xxx01xx0111x1xx
   5068                                                              fneg.  */
   5069                                                           return 208;
   5070                                                         }
   5071                                                     }
   5072                                                   else
   5073                                                     {
   5074                                                       if (((word >> 23) & 0x1) == 0)
   5075                                                         {
   5076                                                           if (((word >> 28) & 0x1) == 0)
   5077                                                             {
   5078                                                               /* 33222222222211111111110000000000
   5079                                                                  10987654321098765432109876543210
   5080                                                                  xxxxxxxxxx0111110xxx11x001110xxx
   5081                                                                  fmaxv.  */
   5082                                                               return 35;
   5083                                                             }
   5084                                                           else
   5085                                                             {
   5086                                                               /* 33222222222211111111110000000000
   5087                                                                  10987654321098765432109876543210
   5088                                                                  xxxxxxxxxx0111110xxx11x001111xxx
   5089                                                                  fmaxp.  */
   5090                                                               return 435;
   5091                                                             }
   5092                                                         }
   5093                                                       else
   5094                                                         {
   5095                                                           if (((word >> 28) & 0x1) == 0)
   5096                                                             {
   5097                                                               /* 33222222222211111111110000000000
   5098                                                                  10987654321098765432109876543210
   5099                                                                  xxxxxxxxxx0111110xxx11x101110xxx
   5100                                                                  fminv.  */
   5101                                                               return 37;
   5102                                                             }
   5103                                                           else
   5104                                                             {
   5105                                                               /* 33222222222211111111110000000000
   5106                                                                  10987654321098765432109876543210
   5107                                                                  xxxxxxxxxx0111110xxx11x101111xxx
   5108                                                                  fminp.  */
   5109                                                               return 437;
   5110                                                             }
   5111                                                         }
   5112                                                     }
   5113                                                 }
   5114                                               else
   5115                                                 {
   5116                                                   if (((word >> 28) & 0x1) == 0)
   5117                                                     {
   5118                                                       /* 33222222222211111111110000000000
   5119                                                          10987654321098765432109876543210
   5120                                                          xxxxxxxxxx0111111xxxx1xx01110xxx
   5121                                                          fsqrt.  */
   5122                                                       return 214;
   5123                                                     }
   5124                                                   else
   5125                                                     {
   5126                                                       /* 33222222222211111111110000000000
   5127                                                          10987654321098765432109876543210
   5128                                                          xxxxxxxxxx0111111xxxx1xx01111xxx
   5129                                                          frecpx.  */
   5130                                                       return 412;
   5131                                                     }
   5132                                                 }
   5133                                             }
   5134                                         }
   5135                                     }
   5136                                 }
   5137                             }
   5138                         }
   5139                       else
   5140                         {
   5141                           if (((word >> 11) & 0x1) == 0)
   5142                             {
   5143                               if (((word >> 28) & 0x1) == 0)
   5144                                 {
   5145                                   if (((word >> 12) & 0x1) == 0)
   5146                                     {
   5147                                       if (((word >> 13) & 0x1) == 0)
   5148                                         {
   5149                                           if (((word >> 14) & 0x1) == 0)
   5150                                             {
   5151                                               if (((word >> 15) & 0x1) == 0)
   5152                                                 {
   5153                                                   if (((word >> 29) & 0x1) == 0)
   5154                                                     {
   5155                                                       /* 33222222222211111111110000000000
   5156                                                          10987654321098765432109876543210
   5157                                                          xxxxxxxxxx100000xxxxx1xx011100xx
   5158                                                          shadd.  */
   5159                                                       return 221;
   5160                                                     }
   5161                                                   else
   5162                                                     {
   5163                                                       /* 33222222222211111111110000000000
   5164                                                          10987654321098765432109876543210
   5165                                                          xxxxxxxxxx100000xxxxx1xx011101xx
   5166                                                          uhadd.  */
   5167                                                       return 261;
   5168                                                     }
   5169                                                 }
   5170                                               else
   5171                                                 {
   5172                                                   if (((word >> 29) & 0x1) == 0)
   5173                                                     {
   5174                                                       /* 33222222222211111111110000000000
   5175                                                          10987654321098765432109876543210
   5176                                                          xxxxxxxxxx100001xxxxx1xx011100xx
   5177                                                          add.  */
   5178                                                       return 236;
   5179                                                     }
   5180                                                   else
   5181                                                     {
   5182                                                       /* 33222222222211111111110000000000
   5183                                                          10987654321098765432109876543210
   5184                                                          xxxxxxxxxx100001xxxxx1xx011101xx
   5185                                                          sub.  */
   5186                                                       return 276;
   5187                                                     }
   5188                                                 }
   5189                                             }
   5190                                           else
   5191                                             {
   5192                                               if (((word >> 15) & 0x1) == 0)
   5193                                                 {
   5194                                                   if (((word >> 29) & 0x1) == 0)
   5195                                                     {
   5196                                                       /* 33222222222211111111110000000000
   5197                                                          10987654321098765432109876543210
   5198                                                          xxxxxxxxxx100010xxxxx1xx011100xx
   5199                                                          sshl.  */
   5200                                                       return 228;
   5201                                                     }
   5202                                                   else
   5203                                                     {
   5204                                                       /* 33222222222211111111110000000000
   5205                                                          10987654321098765432109876543210
   5206                                                          xxxxxxxxxx100010xxxxx1xx011101xx
   5207                                                          ushl.  */
   5208                                                       return 268;
   5209                                                     }
   5210                                                 }
   5211                                               else
   5212                                                 {
   5213                                                   if (((word >> 23) & 0x1) == 0)
   5214                                                     {
   5215                                                       if (((word >> 29) & 0x1) == 0)
   5216                                                         {
   5217                                                           /* 33222222222211111111110000000000
   5218                                                              10987654321098765432109876543210
   5219                                                              xxxxxxxxxx100011xxxxx1x0011100xx
   5220                                                              fmaxnm.  */
   5221                                                           return 244;
   5222                                                         }
   5223                                                       else
   5224                                                         {
   5225                                                           /* 33222222222211111111110000000000
   5226                                                              10987654321098765432109876543210
   5227                                                              xxxxxxxxxx100011xxxxx1x0011101xx
   5228                                                              fmaxnmp.  */
   5229                                                           return 283;
   5230                                                         }
   5231                                                     }
   5232                                                   else
   5233                                                     {
   5234                                                       if (((word >> 29) & 0x1) == 0)
   5235                                                         {
   5236                                                           /* 33222222222211111111110000000000
   5237                                                              10987654321098765432109876543210
   5238                                                              xxxxxxxxxx100011xxxxx1x1011100xx
   5239                                                              fminnm.  */
   5240                                                           return 253;
   5241                                                         }
   5242                                                       else
   5243                                                         {
   5244                                                           /* 33222222222211111111110000000000
   5245                                                              10987654321098765432109876543210
   5246                                                              xxxxxxxxxx100011xxxxx1x1011101xx
   5247                                                              fminnmp.  */
   5248                                                           return 292;
   5249                                                         }
   5250                                                     }
   5251                                                 }
   5252                                             }
   5253                                         }
   5254                                       else
   5255                                         {
   5256                                           if (((word >> 14) & 0x1) == 0)
   5257                                             {
   5258                                               if (((word >> 15) & 0x1) == 0)
   5259                                                 {
   5260                                                   if (((word >> 29) & 0x1) == 0)
   5261                                                     {
   5262                                                       /* 33222222222211111111110000000000
   5263                                                          10987654321098765432109876543210
   5264                                                          xxxxxxxxxx100100xxxxx1xx011100xx
   5265                                                          shsub.  */
   5266                                                       return 224;
   5267                                                     }
   5268                                                   else
   5269                                                     {
   5270                                                       /* 33222222222211111111110000000000
   5271                                                          10987654321098765432109876543210
   5272                                                          xxxxxxxxxx100100xxxxx1xx011101xx
   5273                                                          uhsub.  */
   5274                                                       return 264;
   5275                                                     }
   5276                                                 }
   5277                                               else
   5278                                                 {
   5279                                                   if (((word >> 29) & 0x1) == 0)
   5280                                                     {
   5281                                                       /* 33222222222211111111110000000000
   5282                                                          10987654321098765432109876543210
   5283                                                          xxxxxxxxxx100101xxxxx1xx011100xx
   5284                                                          smaxp.  */
   5285                                                       return 240;
   5286                                                     }
   5287                                                   else
   5288                                                     {
   5289                                                       /* 33222222222211111111110000000000
   5290                                                          10987654321098765432109876543210
   5291                                                          xxxxxxxxxx100101xxxxx1xx011101xx
   5292                                                          umaxp.  */
   5293                                                       return 280;
   5294                                                     }
   5295                                                 }
   5296                                             }
   5297                                           else
   5298                                             {
   5299                                               if (((word >> 15) & 0x1) == 0)
   5300                                                 {
   5301                                                   if (((word >> 29) & 0x1) == 0)
   5302                                                     {
   5303                                                       /* 33222222222211111111110000000000
   5304                                                          10987654321098765432109876543210
   5305                                                          xxxxxxxxxx100110xxxxx1xx011100xx
   5306                                                          smax.  */
   5307                                                       return 232;
   5308                                                     }
   5309                                                   else
   5310                                                     {
   5311                                                       /* 33222222222211111111110000000000
   5312                                                          10987654321098765432109876543210
   5313                                                          xxxxxxxxxx100110xxxxx1xx011101xx
   5314                                                          umax.  */
   5315                                                       return 272;
   5316                                                     }
   5317                                                 }
   5318                                               else
   5319                                                 {
   5320                                                   if (((word >> 23) & 0x1) == 0)
   5321                                                     {
   5322                                                       if (((word >> 29) & 0x1) == 0)
   5323                                                         {
   5324                                                           /* 33222222222211111111110000000000
   5325                                                              10987654321098765432109876543210
   5326                                                              xxxxxxxxxx100111xxxxx1x0011100xx
   5327                                                              fcmeq.  */
   5328                                                           return 248;
   5329                                                         }
   5330                                                       else
   5331                                                         {
   5332                                                           /* 33222222222211111111110000000000
   5333                                                              10987654321098765432109876543210
   5334                                                              xxxxxxxxxx100111xxxxx1x0011101xx
   5335                                                              fcmge.  */
   5336                                                           return 286;
   5337                                                         }
   5338                                                     }
   5339                                                   else
   5340                                                     {
   5341                                                       /* 33222222222211111111110000000000
   5342                                                          10987654321098765432109876543210
   5343                                                          xxxxxxxxxx100111xxxxx1x101110xxx
   5344                                                          fcmgt.  */
   5345                                                       return 294;
   5346                                                     }
   5347                                                 }
   5348                                             }
   5349                                         }
   5350                                     }
   5351                                   else
   5352                                     {
   5353                                       if (((word >> 13) & 0x1) == 0)
   5354                                         {
   5355                                           if (((word >> 14) & 0x1) == 0)
   5356                                             {
   5357                                               if (((word >> 15) & 0x1) == 0)
   5358                                                 {
   5359                                                   if (((word >> 29) & 0x1) == 0)
   5360                                                     {
   5361                                                       /* 33222222222211111111110000000000
   5362                                                          10987654321098765432109876543210
   5363                                                          xxxxxxxxxx101000xxxxx1xx011100xx
   5364                                                          srhadd.  */
   5365                                                       return 223;
   5366                                                     }
   5367                                                   else
   5368                                                     {
   5369                                                       /* 33222222222211111111110000000000
   5370                                                          10987654321098765432109876543210
   5371                                                          xxxxxxxxxx101000xxxxx1xx011101xx
   5372                                                          urhadd.  */
   5373                                                       return 263;
   5374                                                     }
   5375                                                 }
   5376                                               else
   5377                                                 {
   5378                                                   if (((word >> 29) & 0x1) == 0)
   5379                                                     {
   5380                                                       /* 33222222222211111111110000000000
   5381                                                          10987654321098765432109876543210
   5382                                                          xxxxxxxxxx101001xxxxx1xx011100xx
   5383                                                          mla.  */
   5384                                                       return 238;
   5385                                                     }
   5386                                                   else
   5387                                                     {
   5388                                                       /* 33222222222211111111110000000000
   5389                                                          10987654321098765432109876543210
   5390                                                          xxxxxxxxxx101001xxxxx1xx011101xx
   5391                                                          mls.  */
   5392                                                       return 278;
   5393                                                     }
   5394                                                 }
   5395                                             }
   5396                                           else
   5397                                             {
   5398                                               if (((word >> 15) & 0x1) == 0)
   5399                                                 {
   5400                                                   if (((word >> 29) & 0x1) == 0)
   5401                                                     {
   5402                                                       /* 33222222222211111111110000000000
   5403                                                          10987654321098765432109876543210
   5404                                                          xxxxxxxxxx101010xxxxx1xx011100xx
   5405                                                          srshl.  */
   5406                                                       return 230;
   5407                                                     }
   5408                                                   else
   5409                                                     {
   5410                                                       /* 33222222222211111111110000000000
   5411                                                          10987654321098765432109876543210
   5412                                                          xxxxxxxxxx101010xxxxx1xx011101xx
   5413                                                          urshl.  */
   5414                                                       return 270;
   5415                                                     }
   5416                                                 }
   5417                                               else
   5418                                                 {
   5419                                                   if (((word >> 23) & 0x1) == 0)
   5420                                                     {
   5421                                                       if (((word >> 29) & 0x1) == 0)
   5422                                                         {
   5423                                                           /* 33222222222211111111110000000000
   5424                                                              10987654321098765432109876543210
   5425                                                              xxxxxxxxxx101011xxxxx1x0011100xx
   5426                                                              fadd.  */
   5427                                                           return 246;
   5428                                                         }
   5429                                                       else
   5430                                                         {
   5431                                                           /* 33222222222211111111110000000000
   5432                                                              10987654321098765432109876543210
   5433                                                              xxxxxxxxxx101011xxxxx1x0011101xx
   5434                                                              faddp.  */
   5435                                                           return 284;
   5436                                                         }
   5437                                                     }
   5438                                                   else
   5439                                                     {
   5440                                                       if (((word >> 29) & 0x1) == 0)
   5441                                                         {
   5442                                                           /* 33222222222211111111110000000000
   5443                                                              10987654321098765432109876543210
   5444                                                              xxxxxxxxxx101011xxxxx1x1011100xx
   5445                                                              fsub.  */
   5446                                                           return 255;
   5447                                                         }
   5448                                                       else
   5449                                                         {
   5450                                                           /* 33222222222211111111110000000000
   5451                                                              10987654321098765432109876543210
   5452                                                              xxxxxxxxxx101011xxxxx1x1011101xx
   5453                                                              fabd.  */
   5454                                                           return 293;
   5455                                                         }
   5456                                                     }
   5457                                                 }
   5458                                             }
   5459                                         }
   5460                                       else
   5461                                         {
   5462                                           if (((word >> 14) & 0x1) == 0)
   5463                                             {
   5464                                               if (((word >> 15) & 0x1) == 0)
   5465                                                 {
   5466                                                   if (((word >> 29) & 0x1) == 0)
   5467                                                     {
   5468                                                       /* 33222222222211111111110000000000
   5469                                                          10987654321098765432109876543210
   5470                                                          xxxxxxxxxx101100xxxxx1xx011100xx
   5471                                                          cmgt.  */
   5472                                                       return 226;
   5473                                                     }
   5474                                                   else
   5475                                                     {
   5476                                                       /* 33222222222211111111110000000000
   5477                                                          10987654321098765432109876543210
   5478                                                          xxxxxxxxxx101100xxxxx1xx011101xx
   5479                                                          cmhi.  */
   5480                                                       return 266;
   5481                                                     }
   5482                                                 }
   5483                                               else
   5484                                                 {
   5485                                                   if (((word >> 29) & 0x1) == 0)
   5486                                                     {
   5487                                                       /* 33222222222211111111110000000000
   5488                                                          10987654321098765432109876543210
   5489                                                          xxxxxxxxxx101101xxxxx1xx011100xx
   5490                                                          sqdmulh.  */
   5491                                                       return 242;
   5492                                                     }
   5493                                                   else
   5494                                                     {
   5495                                                       /* 33222222222211111111110000000000
   5496                                                          10987654321098765432109876543210
   5497                                                          xxxxxxxxxx101101xxxxx1xx011101xx
   5498                                                          sqrdmulh.  */
   5499                                                       return 282;
   5500                                                     }
   5501                                                 }
   5502                                             }
   5503                                           else
   5504                                             {
   5505                                               if (((word >> 15) & 0x1) == 0)
   5506                                                 {
   5507                                                   if (((word >> 29) & 0x1) == 0)
   5508                                                     {
   5509                                                       /* 33222222222211111111110000000000
   5510                                                          10987654321098765432109876543210
   5511                                                          xxxxxxxxxx101110xxxxx1xx011100xx
   5512                                                          sabd.  */
   5513                                                       return 234;
   5514                                                     }
   5515                                                   else
   5516                                                     {
   5517                                                       /* 33222222222211111111110000000000
   5518                                                          10987654321098765432109876543210
   5519                                                          xxxxxxxxxx101110xxxxx1xx011101xx
   5520                                                          uabd.  */
   5521                                                       return 274;
   5522                                                     }
   5523                                                 }
   5524                                               else
   5525                                                 {
   5526                                                   if (((word >> 23) & 0x1) == 0)
   5527                                                     {
   5528                                                       if (((word >> 29) & 0x1) == 0)
   5529                                                         {
   5530                                                           /* 33222222222211111111110000000000
   5531                                                              10987654321098765432109876543210
   5532                                                              xxxxxxxxxx101111xxxxx1x0011100xx
   5533                                                              fmax.  */
   5534                                                           return 249;
   5535                                                         }
   5536                                                       else
   5537                                                         {
   5538                                                           /* 33222222222211111111110000000000
   5539                                                              10987654321098765432109876543210
   5540                                                              xxxxxxxxxx101111xxxxx1x0011101xx
   5541                                                              fmaxp.  */
   5542                                                           return 288;
   5543                                                         }
   5544                                                     }
   5545                                                   else
   5546                                                     {
   5547                                                       if (((word >> 29) & 0x1) == 0)
   5548                                                         {
   5549                                                           /* 33222222222211111111110000000000
   5550                                                              10987654321098765432109876543210
   5551                                                              xxxxxxxxxx101111xxxxx1x1011100xx
   5552                                                              fmin.  */
   5553                                                           return 256;
   5554                                                         }
   5555                                                       else
   5556                                                         {
   5557                                                           /* 33222222222211111111110000000000
   5558                                                              10987654321098765432109876543210
   5559                                                              xxxxxxxxxx101111xxxxx1x1011101xx
   5560                                                              fminp.  */
   5561                                                           return 296;
   5562                                                         }
   5563                                                     }
   5564                                                 }
   5565                                             }
   5566                                         }
   5567                                     }
   5568                                 }
   5569                               else
   5570                                 {
   5571                                   if (((word >> 29) & 0x1) == 0)
   5572                                     {
   5573                                       if (((word >> 30) & 0x1) == 0)
   5574                                         {
   5575                                           if (((word >> 4) & 0x1) == 0)
   5576                                             {
   5577                                               /* 33222222222211111111110000000000
   5578                                                  10987654321098765432109876543210
   5579                                                  xxxx0xxxxx10xxxxxxxxx1xx0111100x
   5580                                                  fccmp.  */
   5581                                               return 608;
   5582                                             }
   5583                                           else
   5584                                             {
   5585                                               /* 33222222222211111111110000000000
   5586                                                  10987654321098765432109876543210
   5587                                                  xxxx1xxxxx10xxxxxxxxx1xx0111100x
   5588                                                  fccmpe.  */
   5589                                               return 609;
   5590                                             }
   5591                                         }
   5592                                       else
   5593                                         {
   5594                                           if (((word >> 12) & 0x1) == 0)
   5595                                             {
   5596                                               if (((word >> 13) & 0x1) == 0)
   5597                                                 {
   5598                                                   if (((word >> 14) & 0x1) == 0)
   5599                                                     {
   5600                                                       /* 33222222222211111111110000000000
   5601                                                          10987654321098765432109876543210
   5602                                                          xxxxxxxxxx10000xxxxxx1xx0111101x
   5603                                                          add.  */
   5604                                                       return 451;
   5605                                                     }
   5606                                                   else
   5607                                                     {
   5608                                                       /* 33222222222211111111110000000000
   5609                                                          10987654321098765432109876543210
   5610                                                          xxxxxxxxxx10001xxxxxx1xx0111101x
   5611                                                          sshl.  */
   5612                                                       return 449;
   5613                                                     }
   5614                                                 }
   5615                                               else
   5616                                                 {
   5617                                                   /* 33222222222211111111110000000000
   5618                                                      10987654321098765432109876543210
   5619                                                      xxxxxxxxxx1001xxxxxxx1xx0111101x
   5620                                                      fcmeq.  */
   5621                                                   return 444;
   5622                                                 }
   5623                                             }
   5624                                           else
   5625                                             {
   5626                                               if (((word >> 13) & 0x1) == 0)
   5627                                                 {
   5628                                                   /* 33222222222211111111110000000000
   5629                                                      10987654321098765432109876543210
   5630                                                      xxxxxxxxxx1010xxxxxxx1xx0111101x
   5631                                                      srshl.  */
   5632                                                   return 450;
   5633                                                 }
   5634                                               else
   5635                                                 {
   5636                                                   if (((word >> 15) & 0x1) == 0)
   5637                                                     {
   5638                                                       /* 33222222222211111111110000000000
   5639                                                          10987654321098765432109876543210
   5640                                                          xxxxxxxxxx1011x0xxxxx1xx0111101x
   5641                                                          cmgt.  */
   5642                                                       return 447;
   5643                                                     }
   5644                                                   else
   5645                                                     {
   5646                                                       /* 33222222222211111111110000000000
   5647                                                          10987654321098765432109876543210
   5648                                                          xxxxxxxxxx1011x1xxxxx1xx0111101x
   5649                                                          sqdmulh.  */
   5650                                                       return 442;
   5651                                                     }
   5652                                                 }
   5653                                             }
   5654                                         }
   5655                                     }
   5656                                   else
   5657                                     {
   5658                                       if (((word >> 12) & 0x1) == 0)
   5659                                         {
   5660                                           if (((word >> 13) & 0x1) == 0)
   5661                                             {
   5662                                               if (((word >> 14) & 0x1) == 0)
   5663                                                 {
   5664                                                   /* 33222222222211111111110000000000
   5665                                                      10987654321098765432109876543210
   5666                                                      xxxxxxxxxx10000xxxxxx1xx011111xx
   5667                                                      sub.  */
   5668                                                   return 467;
   5669                                                 }
   5670                                               else
   5671                                                 {
   5672                                                   /* 33222222222211111111110000000000
   5673                                                      10987654321098765432109876543210
   5674                                                      xxxxxxxxxx10001xxxxxx1xx011111xx
   5675                                                      ushl.  */
   5676                                                   return 465;
   5677                                                 }
   5678                                             }
   5679                                           else
   5680                                             {
   5681                                               if (((word >> 23) & 0x1) == 0)
   5682                                                 {
   5683                                                   /* 33222222222211111111110000000000
   5684                                                      10987654321098765432109876543210
   5685                                                      xxxxxxxxxx1001xxxxxxx1x0011111xx
   5686                                                      fcmge.  */
   5687                                                   return 458;
   5688                                                 }
   5689                                               else
   5690                                                 {
   5691                                                   /* 33222222222211111111110000000000
   5692                                                      10987654321098765432109876543210
   5693                                                      xxxxxxxxxx1001xxxxxxx1x1011111xx
   5694                                                      fcmgt.  */
   5695                                                   return 461;
   5696                                                 }
   5697                                             }
   5698                                         }
   5699                                       else
   5700                                         {
   5701                                           if (((word >> 13) & 0x1) == 0)
   5702                                             {
   5703                                               if (((word >> 15) & 0x1) == 0)
   5704                                                 {
   5705                                                   /* 33222222222211111111110000000000
   5706                                                      10987654321098765432109876543210
   5707                                                      xxxxxxxxxx1010x0xxxxx1xx011111xx
   5708                                                      urshl.  */
   5709                                                   return 466;
   5710                                                 }
   5711                                               else
   5712                                                 {
   5713                                                   /* 33222222222211111111110000000000
   5714                                                      10987654321098765432109876543210
   5715                                                      xxxxxxxxxx1010x1xxxxx1xx011111xx
   5716                                                      fabd.  */
   5717                                                   return 460;
   5718                                                 }
   5719                                             }
   5720                                           else
   5721                                             {
   5722                                               if (((word >> 15) & 0x1) == 0)
   5723                                                 {
   5724                                                   /* 33222222222211111111110000000000
   5725                                                      10987654321098765432109876543210
   5726                                                      xxxxxxxxxx1011x0xxxxx1xx011111xx
   5727                                                      cmhi.  */
   5728                                                   return 463;
   5729                                                 }
   5730                                               else
   5731                                                 {
   5732                                                   /* 33222222222211111111110000000000
   5733                                                      10987654321098765432109876543210
   5734                                                      xxxxxxxxxx1011x1xxxxx1xx011111xx
   5735                                                      sqrdmulh.  */
   5736                                                   return 457;
   5737                                                 }
   5738                                             }
   5739                                         }
   5740                                     }
   5741                                 }
   5742                             }
   5743                           else
   5744                             {
   5745                               if (((word >> 28) & 0x1) == 0)
   5746                                 {
   5747                                   if (((word >> 12) & 0x1) == 0)
   5748                                     {
   5749                                       if (((word >> 13) & 0x1) == 0)
   5750                                         {
   5751                                           if (((word >> 14) & 0x1) == 0)
   5752                                             {
   5753                                               if (((word >> 15) & 0x1) == 0)
   5754                                                 {
   5755                                                   if (((word >> 29) & 0x1) == 0)
   5756                                                     {
   5757                                                       /* 33222222222211111111110000000000
   5758                                                          10987654321098765432109876543210
   5759                                                          xxxxxxxxxx110000xxxxx1xx011100xx
   5760                                                          sqadd.  */
   5761                                                       return 222;
   5762                                                     }
   5763                                                   else
   5764                                                     {
   5765                                                       /* 33222222222211111111110000000000
   5766                                                          10987654321098765432109876543210
   5767                                                          xxxxxxxxxx110000xxxxx1xx011101xx
   5768                                                          uqadd.  */
   5769                                                       return 262;
   5770                                                     }
   5771                                                 }
   5772                                               else
   5773                                                 {
   5774                                                   if (((word >> 29) & 0x1) == 0)
   5775                                                     {
   5776                                                       /* 33222222222211111111110000000000
   5777                                                          10987654321098765432109876543210
   5778                                                          xxxxxxxxxx110001xxxxx1xx011100xx
   5779                                                          cmtst.  */
   5780                                                       return 237;
   5781                                                     }
   5782                                                   else
   5783                                                     {
   5784                                                       /* 33222222222211111111110000000000
   5785                                                          10987654321098765432109876543210
   5786                                                          xxxxxxxxxx110001xxxxx1xx011101xx
   5787                                                          cmeq.  */
   5788                                                       return 277;
   5789                                                     }
   5790                                                 }
   5791                                             }
   5792                                           else
   5793                                             {
   5794                                               if (((word >> 15) & 0x1) == 0)
   5795                                                 {
   5796                                                   if (((word >> 29) & 0x1) == 0)
   5797                                                     {
   5798                                                       /* 33222222222211111111110000000000
   5799                                                          10987654321098765432109876543210
   5800                                                          xxxxxxxxxx110010xxxxx1xx011100xx
   5801                                                          sqshl.  */
   5802                                                       return 229;
   5803                                                     }
   5804                                                   else
   5805                                                     {
   5806                                                       /* 33222222222211111111110000000000
   5807                                                          10987654321098765432109876543210
   5808                                                          xxxxxxxxxx110010xxxxx1xx011101xx
   5809                                                          uqshl.  */
   5810                                                       return 269;
   5811                                                     }
   5812                                                 }
   5813                                               else
   5814                                                 {
   5815                                                   if (((word >> 23) & 0x1) == 0)
   5816                                                     {
   5817                                                       /* 33222222222211111111110000000000
   5818                                                          10987654321098765432109876543210
   5819                                                          xxxxxxxxxx110011xxxxx1x001110xxx
   5820                                                          fmla.  */
   5821                                                       return 245;
   5822                                                     }
   5823                                                   else
   5824                                                     {
   5825                                                       /* 33222222222211111111110000000000
   5826                                                          10987654321098765432109876543210
   5827                                                          xxxxxxxxxx110011xxxxx1x101110xxx
   5828                                                          fmls.  */
   5829                                                       return 254;
   5830                                                     }
   5831                                                 }
   5832                                             }
   5833                                         }
   5834                                       else
   5835                                         {
   5836                                           if (((word >> 14) & 0x1) == 0)
   5837                                             {
   5838                                               if (((word >> 15) & 0x1) == 0)
   5839                                                 {
   5840                                                   if (((word >> 29) & 0x1) == 0)
   5841                                                     {
   5842                                                       /* 33222222222211111111110000000000
   5843                                                          10987654321098765432109876543210
   5844                                                          xxxxxxxxxx110100xxxxx1xx011100xx
   5845                                                          sqsub.  */
   5846                                                       return 225;
   5847                                                     }
   5848                                                   else
   5849                                                     {
   5850                                                       /* 33222222222211111111110000000000
   5851                                                          10987654321098765432109876543210
   5852                                                          xxxxxxxxxx110100xxxxx1xx011101xx
   5853                                                          uqsub.  */
   5854                                                       return 265;
   5855                                                     }
   5856                                                 }
   5857                                               else
   5858                                                 {
   5859                                                   if (((word >> 29) & 0x1) == 0)
   5860                                                     {
   5861                                                       /* 33222222222211111111110000000000
   5862                                                          10987654321098765432109876543210
   5863                                                          xxxxxxxxxx110101xxxxx1xx011100xx
   5864                                                          sminp.  */
   5865                                                       return 241;
   5866                                                     }
   5867                                                   else
   5868                                                     {
   5869                                                       /* 33222222222211111111110000000000
   5870                                                          10987654321098765432109876543210
   5871                                                          xxxxxxxxxx110101xxxxx1xx011101xx
   5872                                                          uminp.  */
   5873                                                       return 281;
   5874                                                     }
   5875                                                 }
   5876                                             }
   5877                                           else
   5878                                             {
   5879                                               if (((word >> 15) & 0x1) == 0)
   5880                                                 {
   5881                                                   if (((word >> 29) & 0x1) == 0)
   5882                                                     {
   5883                                                       /* 33222222222211111111110000000000
   5884                                                          10987654321098765432109876543210
   5885                                                          xxxxxxxxxx110110xxxxx1xx011100xx
   5886                                                          smin.  */
   5887                                                       return 233;
   5888                                                     }
   5889                                                   else
   5890                                                     {
   5891                                                       /* 33222222222211111111110000000000
   5892                                                          10987654321098765432109876543210
   5893                                                          xxxxxxxxxx110110xxxxx1xx011101xx
   5894                                                          umin.  */
   5895                                                       return 273;
   5896                                                     }
   5897                                                 }
   5898                                               else
   5899                                                 {
   5900                                                   if (((word >> 23) & 0x1) == 0)
   5901                                                     {
   5902                                                       /* 33222222222211111111110000000000
   5903                                                          10987654321098765432109876543210
   5904                                                          xxxxxxxxxx110111xxxxx1x001110xxx
   5905                                                          facge.  */
   5906                                                       return 287;
   5907                                                     }
   5908                                                   else
   5909                                                     {
   5910                                                       /* 33222222222211111111110000000000
   5911                                                          10987654321098765432109876543210
   5912                                                          xxxxxxxxxx110111xxxxx1x101110xxx
   5913                                                          facgt.  */
   5914                                                       return 295;
   5915                                                     }
   5916                                                 }
   5917                                             }
   5918                                         }
   5919                                     }
   5920                                   else
   5921                                     {
   5922                                       if (((word >> 13) & 0x1) == 0)
   5923                                         {
   5924                                           if (((word >> 14) & 0x1) == 0)
   5925                                             {
   5926                                               if (((word >> 15) & 0x1) == 0)
   5927                                                 {
   5928                                                   if (((word >> 22) & 0x1) == 0)
   5929                                                     {
   5930                                                       if (((word >> 23) & 0x1) == 0)
   5931                                                         {
   5932                                                           if (((word >> 29) & 0x1) == 0)
   5933                                                             {
   5934                                                               /* 33222222222211111111110000000000
   5935                                                                  10987654321098765432109876543210
   5936                                                                  xxxxxxxxxx111000xxxxx100011100xx
   5937                                                                  and.  */
   5938                                                               return 251;
   5939                                                             }
   5940                                                           else
   5941                                                             {
   5942                                                               /* 33222222222211111111110000000000
   5943                                                                  10987654321098765432109876543210
   5944                                                                  xxxxxxxxxx111000xxxxx100011101xx
   5945                                                                  eor.  */
   5946                                                               return 290;
   5947                                                             }
   5948                                                         }
   5949                                                       else
   5950                                                         {
   5951                                                           if (((word >> 29) & 0x1) == 0)
   5952                                                             {
   5953                                                               /* 33222222222211111111110000000000
   5954                                                                  10987654321098765432109876543210
   5955                                                                  xxxxxxxxxx111000xxxxx101011100xx
   5956                                                                  orr.  */
   5957                                                               return 258;
   5958                                                             }
   5959                                                           else
   5960                                                             {
   5961                                                               /* 33222222222211111111110000000000
   5962                                                                  10987654321098765432109876543210
   5963                                                                  xxxxxxxxxx111000xxxxx101011101xx
   5964                                                                  bit.  */
   5965                                                               return 297;
   5966                                                             }
   5967                                                         }
   5968                                                     }
   5969                                                   else
   5970                                                     {
   5971                                                       if (((word >> 23) & 0x1) == 0)
   5972                                                         {
   5973                                                           if (((word >> 29) & 0x1) == 0)
   5974                                                             {
   5975                                                               /* 33222222222211111111110000000000
   5976                                                                  10987654321098765432109876543210
   5977                                                                  xxxxxxxxxx111000xxxxx110011100xx
   5978                                                                  bic.  */
   5979                                                               return 252;
   5980                                                             }
   5981                                                           else
   5982                                                             {
   5983                                                               /* 33222222222211111111110000000000
   5984                                                                  10987654321098765432109876543210
   5985                                                                  xxxxxxxxxx111000xxxxx110011101xx
   5986                                                                  bsl.  */
   5987                                                               return 291;
   5988                                                             }
   5989                                                         }
   5990                                                       else
   5991                                                         {
   5992                                                           if (((word >> 29) & 0x1) == 0)
   5993                                                             {
   5994                                                               /* 33222222222211111111110000000000
   5995                                                                  10987654321098765432109876543210
   5996                                                                  xxxxxxxxxx111000xxxxx111011100xx
   5997                                                                  orn.  */
   5998                                                               return 260;
   5999                                                             }
   6000                                                           else
   6001                                                             {
   6002                                                               /* 33222222222211111111110000000000
   6003                                                                  10987654321098765432109876543210
   6004                                                                  xxxxxxxxxx111000xxxxx111011101xx
   6005                                                                  bif.  */
   6006                                                               return 298;
   6007                                                             }
   6008                                                         }
   6009                                                     }
   6010                                                 }
   6011                                               else
   6012                                                 {
   6013                                                   if (((word >> 29) & 0x1) == 0)
   6014                                                     {
   6015                                                       /* 33222222222211111111110000000000
   6016                                                          10987654321098765432109876543210
   6017                                                          xxxxxxxxxx111001xxxxx1xx011100xx
   6018                                                          mul.  */
   6019                                                       return 239;
   6020                                                     }
   6021                                                   else
   6022                                                     {
   6023                                                       /* 33222222222211111111110000000000
   6024                                                          10987654321098765432109876543210
   6025                                                          xxxxxxxxxx111001xxxxx1xx011101xx
   6026                                                          pmul.  */
   6027                                                       return 279;
   6028                                                     }
   6029                                                 }
   6030                                             }
   6031                                           else
   6032                                             {
   6033                                               if (((word >> 15) & 0x1) == 0)
   6034                                                 {
   6035                                                   if (((word >> 29) & 0x1) == 0)
   6036                                                     {
   6037                                                       /* 33222222222211111111110000000000
   6038                                                          10987654321098765432109876543210
   6039                                                          xxxxxxxxxx111010xxxxx1xx011100xx
   6040                                                          sqrshl.  */
   6041                                                       return 231;
   6042                                                     }
   6043                                                   else
   6044                                                     {
   6045                                                       /* 33222222222211111111110000000000
   6046                                                          10987654321098765432109876543210
   6047                                                          xxxxxxxxxx111010xxxxx1xx011101xx
   6048                                                          uqrshl.  */
   6049                                                       return 271;
   6050                                                     }
   6051                                                 }
   6052                                               else
   6053                                                 {
   6054                                                   if (((word >> 29) & 0x1) == 0)
   6055                                                     {
   6056                                                       /* 33222222222211111111110000000000
   6057                                                          10987654321098765432109876543210
   6058                                                          xxxxxxxxxx111011xxxxx1xx011100xx
   6059                                                          fmulx.  */
   6060                                                       return 247;
   6061                                                     }
   6062                                                   else
   6063                                                     {
   6064                                                       /* 33222222222211111111110000000000
   6065                                                          10987654321098765432109876543210
   6066                                                          xxxxxxxxxx111011xxxxx1xx011101xx
   6067                                                          fmul.  */
   6068                                                       return 285;
   6069                                                     }
   6070                                                 }
   6071                                             }
   6072                                         }
   6073                                       else
   6074                                         {
   6075                                           if (((word >> 14) & 0x1) == 0)
   6076                                             {
   6077                                               if (((word >> 15) & 0x1) == 0)
   6078                                                 {
   6079                                                   if (((word >> 29) & 0x1) == 0)
   6080                                                     {
   6081                                                       /* 33222222222211111111110000000000
   6082                                                          10987654321098765432109876543210
   6083                                                          xxxxxxxxxx111100xxxxx1xx011100xx
   6084                                                          cmge.  */
   6085                                                       return 227;
   6086                                                     }
   6087                                                   else
   6088                                                     {
   6089                                                       /* 33222222222211111111110000000000
   6090                                                          10987654321098765432109876543210
   6091                                                          xxxxxxxxxx111100xxxxx1xx011101xx
   6092                                                          cmhs.  */
   6093                                                       return 267;
   6094                                                     }
   6095                                                 }
   6096                                               else
   6097                                                 {
   6098                                                   /* 33222222222211111111110000000000
   6099                                                      10987654321098765432109876543210
   6100                                                      xxxxxxxxxx111101xxxxx1xx01110xxx
   6101                                                      addp.  */
   6102                                                   return 243;
   6103                                                 }
   6104                                             }
   6105                                           else
   6106                                             {
   6107                                               if (((word >> 15) & 0x1) == 0)
   6108                                                 {
   6109                                                   if (((word >> 29) & 0x1) == 0)
   6110                                                     {
   6111                                                       /* 33222222222211111111110000000000
   6112                                                          10987654321098765432109876543210
   6113                                                          xxxxxxxxxx111110xxxxx1xx011100xx
   6114                                                          saba.  */
   6115                                                       return 235;
   6116                                                     }
   6117                                                   else
   6118                                                     {
   6119                                                       /* 33222222222211111111110000000000
   6120                                                          10987654321098765432109876543210
   6121                                                          xxxxxxxxxx111110xxxxx1xx011101xx
   6122                                                          uaba.  */
   6123                                                       return 275;
   6124                                                     }
   6125                                                 }
   6126                                               else
   6127                                                 {
   6128                                                   if (((word >> 23) & 0x1) == 0)
   6129                                                     {
   6130                                                       if (((word >> 29) & 0x1) == 0)
   6131                                                         {
   6132                                                           /* 33222222222211111111110000000000
   6133                                                              10987654321098765432109876543210
   6134                                                              xxxxxxxxxx111111xxxxx1x0011100xx
   6135                                                              frecps.  */
   6136                                                           return 250;
   6137                                                         }
   6138                                                       else
   6139                                                         {
   6140                                                           /* 33222222222211111111110000000000
   6141                                                              10987654321098765432109876543210
   6142                                                              xxxxxxxxxx111111xxxxx1x0011101xx
   6143                                                              fdiv.  */
   6144                                                           return 289;
   6145                                                         }
   6146                                                     }
   6147                                                   else
   6148                                                     {
   6149                                                       /* 33222222222211111111110000000000
   6150                                                          10987654321098765432109876543210
   6151                                                          xxxxxxxxxx111111xxxxx1x101110xxx
   6152                                                          frsqrts.  */
   6153                                                       return 257;
   6154                                                     }
   6155                                                 }
   6156                                             }
   6157                                         }
   6158                                     }
   6159                                 }
   6160                               else
   6161                                 {
   6162                                   if (((word >> 29) & 0x1) == 0)
   6163                                     {
   6164                                       if (((word >> 30) & 0x1) == 0)
   6165                                         {
   6166                                           /* 33222222222211111111110000000000
   6167                                              10987654321098765432109876543210
   6168                                              xxxxxxxxxx11xxxxxxxxx1xx0111100x
   6169                                              fcsel.  */
   6170                                           return 640;
   6171                                         }
   6172                                       else
   6173                                         {
   6174                                           if (((word >> 12) & 0x1) == 0)
   6175                                             {
   6176                                               if (((word >> 13) & 0x1) == 0)
   6177                                                 {
   6178                                                   if (((word >> 14) & 0x1) == 0)
   6179                                                     {
   6180                                                       if (((word >> 15) & 0x1) == 0)
   6181                                                         {
   6182                                                           /* 33222222222211111111110000000000
   6183                                                              10987654321098765432109876543210
   6184                                                              xxxxxxxxxx110000xxxxx1xx0111101x
   6185                                                              sqadd.  */
   6186                                                           return 438;
   6187                                                         }
   6188                                                       else
   6189                                                         {
   6190                                                           /* 33222222222211111111110000000000
   6191                                                              10987654321098765432109876543210
   6192                                                              xxxxxxxxxx110001xxxxx1xx0111101x
   6193                                                              cmtst.  */
   6194                                                           return 452;
   6195                                                         }
   6196                                                     }
   6197                                                   else
   6198                                                     {
   6199                                                       /* 33222222222211111111110000000000
   6200                                                          10987654321098765432109876543210
   6201                                                          xxxxxxxxxx11001xxxxxx1xx0111101x
   6202                                                          sqshl.  */
   6203                                                       return 440;
   6204                                                     }
   6205                                                 }
   6206                                               else
   6207                                                 {
   6208                                                   /* 33222222222211111111110000000000
   6209                                                      10987654321098765432109876543210
   6210                                                      xxxxxxxxxx1101xxxxxxx1xx0111101x
   6211                                                      sqsub.  */
   6212                                                   return 439;
   6213                                                 }
   6214                                             }
   6215                                           else
   6216                                             {
   6217                                               if (((word >> 13) & 0x1) == 0)
   6218                                                 {
   6219                                                   if (((word >> 15) & 0x1) == 0)
   6220                                                     {
   6221                                                       /* 33222222222211111111110000000000
   6222                                                          10987654321098765432109876543210
   6223                                                          xxxxxxxxxx1110x0xxxxx1xx0111101x
   6224                                                          sqrshl.  */
   6225                                                       return 441;
   6226                                                     }
   6227                                                   else
   6228                                                     {
   6229                                                       /* 33222222222211111111110000000000
   6230                                                          10987654321098765432109876543210
   6231                                                          xxxxxxxxxx1110x1xxxxx1xx0111101x
   6232                                                          fmulx.  */
   6233                                                       return 443;
   6234                                                     }
   6235                                                 }
   6236                                               else
   6237                                                 {
   6238                                                   if (((word >> 14) & 0x1) == 0)
   6239                                                     {
   6240                                                       /* 33222222222211111111110000000000
   6241                                                          10987654321098765432109876543210
   6242                                                          xxxxxxxxxx11110xxxxxx1xx0111101x
   6243                                                          cmge.  */
   6244                                                       return 448;
   6245                                                     }
   6246                                                   else
   6247                                                     {
   6248                                                       if (((word >> 23) & 0x1) == 0)
   6249                                                         {
   6250                                                           /* 33222222222211111111110000000000
   6251                                                              10987654321098765432109876543210
   6252                                                              xxxxxxxxxx11111xxxxxx1x00111101x
   6253                                                              frecps.  */
   6254                                                           return 445;
   6255                                                         }
   6256                                                       else
   6257                                                         {
   6258                                                           /* 33222222222211111111110000000000
   6259                                                              10987654321098765432109876543210
   6260                                                              xxxxxxxxxx11111xxxxxx1x10111101x
   6261                                                              frsqrts.  */
   6262                                                           return 446;
   6263                                                         }
   6264                                                     }
   6265                                                 }
   6266                                             }
   6267                                         }
   6268                                     }
   6269                                   else
   6270                                     {
   6271                                       if (((word >> 12) & 0x1) == 0)
   6272                                         {
   6273                                           if (((word >> 13) & 0x1) == 0)
   6274                                             {
   6275                                               if (((word >> 14) & 0x1) == 0)
   6276                                                 {
   6277                                                   if (((word >> 15) & 0x1) == 0)
   6278                                                     {
   6279                                                       /* 33222222222211111111110000000000
   6280                                                          10987654321098765432109876543210
   6281                                                          xxxxxxxxxx110000xxxxx1xx011111xx
   6282                                                          uqadd.  */
   6283                                                       return 453;
   6284                                                     }
   6285                                                   else
   6286                                                     {
   6287                                                       /* 33222222222211111111110000000000
   6288                                                          10987654321098765432109876543210
   6289                                                          xxxxxxxxxx110001xxxxx1xx011111xx
   6290                                                          cmeq.  */
   6291                                                       return 468;
   6292                                                     }
   6293                                                 }
   6294                                               else
   6295                                                 {
   6296                                                   /* 33222222222211111111110000000000
   6297                                                      10987654321098765432109876543210
   6298                                                      xxxxxxxxxx11001xxxxxx1xx011111xx
   6299                                                      uqshl.  */
   6300                                                   return 455;
   6301                                                 }
   6302                                             }
   6303                                           else
   6304                                             {
   6305                                               if (((word >> 14) & 0x1) == 0)
   6306                                                 {
   6307                                                   /* 33222222222211111111110000000000
   6308                                                      10987654321098765432109876543210
   6309                                                      xxxxxxxxxx11010xxxxxx1xx011111xx
   6310                                                      uqsub.  */
   6311                                                   return 454;
   6312                                                 }
   6313                                               else
   6314                                                 {
   6315                                                   if (((word >> 23) & 0x1) == 0)
   6316                                                     {
   6317                                                       /* 33222222222211111111110000000000
   6318                                                          10987654321098765432109876543210
   6319                                                          xxxxxxxxxx11011xxxxxx1x0011111xx
   6320                                                          facge.  */
   6321                                                       return 459;
   6322                                                     }
   6323                                                   else
   6324                                                     {
   6325                                                       /* 33222222222211111111110000000000
   6326                                                          10987654321098765432109876543210
   6327                                                          xxxxxxxxxx11011xxxxxx1x1011111xx
   6328                                                          facgt.  */
   6329                                                       return 462;
   6330                                                     }
   6331                                                 }
   6332                                             }
   6333                                         }
   6334                                       else
   6335                                         {
   6336                                           if (((word >> 13) & 0x1) == 0)
   6337                                             {
   6338                                               /* 33222222222211111111110000000000
   6339                                                  10987654321098765432109876543210
   6340                                                  xxxxxxxxxx1110xxxxxxx1xx011111xx
   6341                                                  uqrshl.  */
   6342                                               return 456;
   6343                                             }
   6344                                           else
   6345                                             {
   6346                                               /* 33222222222211111111110000000000
   6347                                                  10987654321098765432109876543210
   6348                                                  xxxxxxxxxx1111xxxxxxx1xx011111xx
   6349                                                  cmhs.  */
   6350                                               return 464;
   6351                                             }
   6352                                         }
   6353                                     }
   6354                                 }
   6355                             }
   6356                         }
   6357                     }
   6358                 }
   6359               else
   6360                 {
   6361                   if (((word >> 15) & 0x1) == 0)
   6362                     {
   6363                       if (((word >> 28) & 0x1) == 0)
   6364                         {
   6365                           if (((word >> 10) & 0x1) == 0)
   6366                             {
   6367                               if (((word >> 12) & 0x1) == 0)
   6368                                 {
   6369                                   if (((word >> 13) & 0x1) == 0)
   6370                                     {
   6371                                       if (((word >> 14) & 0x1) == 0)
   6372                                         {
   6373                                           /* 33222222222211111111110000000000
   6374                                              10987654321098765432109876543210
   6375                                              xxxxxxxxxx0x0000xxxxxxxx11110xxx
   6376                                              mla.  */
   6377                                           return 110;
   6378                                         }
   6379                                       else
   6380                                         {
   6381                                           /* 33222222222211111111110000000000
   6382                                              10987654321098765432109876543210
   6383                                              xxxxxxxxxx0x0010xxxxxxxx11110xxx
   6384                                              mls.  */
   6385                                           return 113;
   6386                                         }
   6387                                     }
   6388                                   else
   6389                                     {
   6390                                       if (((word >> 14) & 0x1) == 0)
   6391                                         {
   6392                                           if (((word >> 29) & 0x1) == 0)
   6393                                             {
   6394                                               if (((word >> 30) & 0x1) == 0)
   6395                                                 {
   6396                                                   /* 33222222222211111111110000000000
   6397                                                      10987654321098765432109876543210
   6398                                                      xxxxxxxxxx0x0100xxxxxxxx1111000x
   6399                                                      smlal.  */
   6400                                                   return 92;
   6401                                                 }
   6402                                               else
   6403                                                 {
   6404                                                   /* 33222222222211111111110000000000
   6405                                                      10987654321098765432109876543210
   6406                                                      xxxxxxxxxx0x0100xxxxxxxx1111001x
   6407                                                      smlal2.  */
   6408                                                   return 93;
   6409                                                 }
   6410                                             }
   6411                                           else
   6412                                             {
   6413                                               if (((word >> 30) & 0x1) == 0)
   6414                                                 {
   6415                                                   /* 33222222222211111111110000000000
   6416                                                      10987654321098765432109876543210
   6417                                                      xxxxxxxxxx0x0100xxxxxxxx1111010x
   6418                                                      umlal.  */
   6419                                                   return 111;
   6420                                                 }
   6421                                               else
   6422                                                 {
   6423                                                   /* 33222222222211111111110000000000
   6424                                                      10987654321098765432109876543210
   6425                                                      xxxxxxxxxx0x0100xxxxxxxx1111011x
   6426                                                      umlal2.  */
   6427                                                   return 112;
   6428                                                 }
   6429                                             }
   6430                                         }
   6431                                       else
   6432                                         {
   6433                                           if (((word >> 29) & 0x1) == 0)
   6434                                             {
   6435                                               if (((word >> 30) & 0x1) == 0)
   6436                                                 {
   6437                                                   /* 33222222222211111111110000000000
   6438                                                      10987654321098765432109876543210
   6439                                                      xxxxxxxxxx0x0110xxxxxxxx1111000x
   6440                                                      smlsl.  */
   6441                                                   return 96;
   6442                                                 }
   6443                                               else
   6444                                                 {
   6445                                                   /* 33222222222211111111110000000000
   6446                                                      10987654321098765432109876543210
   6447                                                      xxxxxxxxxx0x0110xxxxxxxx1111001x
   6448                                                      smlsl2.  */
   6449                                                   return 97;
   6450                                                 }
   6451                                             }
   6452                                           else
   6453                                             {
   6454                                               if (((word >> 30) & 0x1) == 0)
   6455                                                 {
   6456                                                   /* 33222222222211111111110000000000
   6457                                                      10987654321098765432109876543210
   6458                                                      xxxxxxxxxx0x0110xxxxxxxx1111010x
   6459                                                      umlsl.  */
   6460                                                   return 114;
   6461                                                 }
   6462                                               else
   6463                                                 {
   6464                                                   /* 33222222222211111111110000000000
   6465                                                      10987654321098765432109876543210
   6466                                                      xxxxxxxxxx0x0110xxxxxxxx1111011x
   6467                                                      umlsl2.  */
   6468                                                   return 115;
   6469                                                 }
   6470                                             }
   6471                                         }
   6472                                     }
   6473                                 }
   6474                               else
   6475                                 {
   6476                                   if (((word >> 13) & 0x1) == 0)
   6477                                     {
   6478                                       if (((word >> 14) & 0x1) == 0)
   6479                                         {
   6480                                           /* 33222222222211111111110000000000
   6481                                              10987654321098765432109876543210
   6482                                              xxxxxxxxxx0x1000xxxxxxxx11110xxx
   6483                                              fmla.  */
   6484                                           return 107;
   6485                                         }
   6486                                       else
   6487                                         {
   6488                                           /* 33222222222211111111110000000000
   6489                                              10987654321098765432109876543210
   6490                                              xxxxxxxxxx0x1010xxxxxxxx11110xxx
   6491                                              fmls.  */
   6492                                           return 108;
   6493                                         }
   6494                                     }
   6495                                   else
   6496                                     {
   6497                                       if (((word >> 14) & 0x1) == 0)
   6498                                         {
   6499                                           if (((word >> 30) & 0x1) == 0)
   6500                                             {
   6501                                               /* 33222222222211111111110000000000
   6502                                                  10987654321098765432109876543210
   6503                                                  xxxxxxxxxx0x1100xxxxxxxx11110x0x
   6504                                                  sqdmlal.  */
   6505                                               return 94;
   6506                                             }
   6507                                           else
   6508                                             {
   6509                                               /* 33222222222211111111110000000000
   6510                                                  10987654321098765432109876543210
   6511                                                  xxxxxxxxxx0x1100xxxxxxxx11110x1x
   6512                                                  sqdmlal2.  */
   6513                                               return 95;
   6514                                             }
   6515                                         }
   6516                                       else
   6517                                         {
   6518                                           if (((word >> 30) & 0x1) == 0)
   6519                                             {
   6520                                               /* 33222222222211111111110000000000
   6521                                                  10987654321098765432109876543210
   6522                                                  xxxxxxxxxx0x1110xxxxxxxx11110x0x
   6523                                                  sqdmlsl.  */
   6524                                               return 98;
   6525                                             }
   6526                                           else
   6527                                             {
   6528                                               /* 33222222222211111111110000000000
   6529                                                  10987654321098765432109876543210
   6530                                                  xxxxxxxxxx0x1110xxxxxxxx11110x1x
   6531                                                  sqdmlsl2.  */
   6532                                               return 99;
   6533                                             }
   6534                                         }
   6535                                     }
   6536                                 }
   6537                             }
   6538                           else
   6539                             {
   6540                               if (((word >> 12) & 0x1) == 0)
   6541                                 {
   6542                                   if (((word >> 29) & 0x1) == 0)
   6543                                     {
   6544                                       /* 33222222222211111111110000000000
   6545                                          10987654321098765432109876543210
   6546                                          xxxxxxxxxx1x0xx0xxxxxxxx111100xx
   6547                                          movi.  */
   6548                                       return 120;
   6549                                     }
   6550                                   else
   6551                                     {
   6552                                       /* 33222222222211111111110000000000
   6553                                          10987654321098765432109876543210
   6554                                          xxxxxxxxxx1x0xx0xxxxxxxx111101xx
   6555                                          mvni.  */
   6556                                       return 127;
   6557                                     }
   6558                                 }
   6559                               else
   6560                                 {
   6561                                   if (((word >> 29) & 0x1) == 0)
   6562                                     {
   6563                                       /* 33222222222211111111110000000000
   6564                                          10987654321098765432109876543210
   6565                                          xxxxxxxxxx1x1xx0xxxxxxxx111100xx
   6566                                          orr.  */
   6567                                       return 121;
   6568                                     }
   6569                                   else
   6570                                     {
   6571                                       /* 33222222222211111111110000000000
   6572                                          10987654321098765432109876543210
   6573                                          xxxxxxxxxx1x1xx0xxxxxxxx111101xx
   6574                                          bic.  */
   6575                                       return 128;
   6576                                     }
   6577                                 }
   6578                             }
   6579                         }
   6580                       else
   6581                         {
   6582                           if (((word >> 29) & 0x1) == 0)
   6583                             {
   6584                               if (((word >> 30) & 0x1) == 0)
   6585                                 {
   6586                                   if (((word >> 21) & 0x1) == 0)
   6587                                     {
   6588                                       /* 33222222222211111111110000000000
   6589                                          10987654321098765432109876543210
   6590                                          xxxxxxxxxxxxxxx0xxxxx0xx1111100x
   6591                                          fmadd.  */
   6592                                       return 635;
   6593                                     }
   6594                                   else
   6595                                     {
   6596                                       /* 33222222222211111111110000000000
   6597                                          10987654321098765432109876543210
   6598                                          xxxxxxxxxxxxxxx0xxxxx1xx1111100x
   6599                                          fnmadd.  */
   6600                                       return 637;
   6601                                     }
   6602                                 }
   6603                               else
   6604                                 {
   6605                                   if (((word >> 10) & 0x1) == 0)
   6606                                     {
   6607                                       if (((word >> 13) & 0x1) == 0)
   6608                                         {
   6609                                           if (((word >> 14) & 0x1) == 0)
   6610                                             {
   6611                                               /* 33222222222211111111110000000000
   6612                                                  10987654321098765432109876543210
   6613                                                  xxxxxxxxxx0xx000xxxxxxxx1111101x
   6614                                                  fmla.  */
   6615                                               return 351;
   6616                                             }
   6617                                           else
   6618                                             {
   6619                                               /* 33222222222211111111110000000000
   6620                                                  10987654321098765432109876543210
   6621                                                  xxxxxxxxxx0xx010xxxxxxxx1111101x
   6622                                                  fmls.  */
   6623                                               return 352;
   6624                                             }
   6625                                         }
   6626                                       else
   6627                                         {
   6628                                           if (((word >> 14) & 0x1) == 0)
   6629                                             {
   6630                                               /* 33222222222211111111110000000000
   6631                                                  10987654321098765432109876543210
   6632                                                  xxxxxxxxxx0xx100xxxxxxxx1111101x
   6633                                                  sqdmlal.  */
   6634                                               return 346;
   6635                                             }
   6636                                           else
   6637                                             {
   6638                                               /* 33222222222211111111110000000000
   6639                                                  10987654321098765432109876543210
   6640                                                  xxxxxxxxxx0xx110xxxxxxxx1111101x
   6641                                                  sqdmlsl.  */
   6642                                               return 347;
   6643                                             }
   6644                                         }
   6645                                     }
   6646                                   else
   6647                                     {
   6648                                       if (((word >> 12) & 0x1) == 0)
   6649                                         {
   6650                                           if (((word >> 13) & 0x1) == 0)
   6651                                             {
   6652                                               /* 33222222222211111111110000000000
   6653                                                  10987654321098765432109876543210
   6654                                                  xxxxxxxxxx1x00x0xxxxxxxx1111101x
   6655                                                  sshr.  */
   6656                                               return 469;
   6657                                             }
   6658                                           else
   6659                                             {
   6660                                               /* 33222222222211111111110000000000
   6661                                                  10987654321098765432109876543210
   6662                                                  xxxxxxxxxx1x01x0xxxxxxxx1111101x
   6663                                                  srshr.  */
   6664                                               return 471;
   6665                                             }
   6666                                         }
   6667                                       else
   6668                                         {
   6669                                           if (((word >> 13) & 0x1) == 0)
   6670                                             {
   6671                                               if (((word >> 14) & 0x1) == 0)
   6672                                                 {
   6673                                                   /* 33222222222211111111110000000000
   6674                                                      10987654321098765432109876543210
   6675                                                      xxxxxxxxxx1x1000xxxxxxxx1111101x
   6676                                                      ssra.  */
   6677                                                   return 470;
   6678                                                 }
   6679                                               else
   6680                                                 {
   6681                                                   /* 33222222222211111111110000000000
   6682                                                      10987654321098765432109876543210
   6683                                                      xxxxxxxxxx1x1010xxxxxxxx1111101x
   6684                                                      shl.  */
   6685                                                   return 473;
   6686                                                 }
   6687                                             }
   6688                                           else
   6689                                             {
   6690                                               if (((word >> 14) & 0x1) == 0)
   6691                                                 {
   6692                                                   /* 33222222222211111111110000000000
   6693                                                      10987654321098765432109876543210
   6694                                                      xxxxxxxxxx1x1100xxxxxxxx1111101x
   6695                                                      srsra.  */
   6696                                                   return 472;
   6697                                                 }
   6698                                               else
   6699                                                 {
   6700                                                   /* 33222222222211111111110000000000
   6701                                                      10987654321098765432109876543210
   6702                                                      xxxxxxxxxx1x1110xxxxxxxx1111101x
   6703                                                      sqshl.  */
   6704                                                   return 474;
   6705                                                 }
   6706                                             }
   6707                                         }
   6708                                     }
   6709                                 }
   6710                             }
   6711                           else
   6712                             {
   6713                               if (((word >> 12) & 0x1) == 0)
   6714                                 {
   6715                                   if (((word >> 13) & 0x1) == 0)
   6716                                     {
   6717                                       if (((word >> 14) & 0x1) == 0)
   6718                                         {
   6719                                           /* 33222222222211111111110000000000
   6720                                              10987654321098765432109876543210
   6721                                              xxxxxxxxxxxx0000xxxxxxxx111111xx
   6722                                              ushr.  */
   6723                                           return 479;
   6724                                         }
   6725                                       else
   6726                                         {
   6727                                           /* 33222222222211111111110000000000
   6728                                              10987654321098765432109876543210
   6729                                              xxxxxxxxxxxx0010xxxxxxxx111111xx
   6730                                              sri.  */
   6731                                           return 483;
   6732                                         }
   6733                                     }
   6734                                   else
   6735                                     {
   6736                                       if (((word >> 14) & 0x1) == 0)
   6737                                         {
   6738                                           /* 33222222222211111111110000000000
   6739                                              10987654321098765432109876543210
   6740                                              xxxxxxxxxxxx0100xxxxxxxx111111xx
   6741                                              urshr.  */
   6742                                           return 481;
   6743                                         }
   6744                                       else
   6745                                         {
   6746                                           /* 33222222222211111111110000000000
   6747                                              10987654321098765432109876543210
   6748                                              xxxxxxxxxxxx0110xxxxxxxx111111xx
   6749                                              sqshlu.  */
   6750                                           return 485;
   6751                                         }
   6752                                     }
   6753                                 }
   6754                               else
   6755                                 {
   6756                                   if (((word >> 13) & 0x1) == 0)
   6757                                     {
   6758                                       if (((word >> 14) & 0x1) == 0)
   6759                                         {
   6760                                           /* 33222222222211111111110000000000
   6761                                              10987654321098765432109876543210
   6762                                              xxxxxxxxxxxx1000xxxxxxxx111111xx
   6763                                              usra.  */
   6764                                           return 480;
   6765                                         }
   6766                                       else
   6767                                         {
   6768                                           /* 33222222222211111111110000000000
   6769                                              10987654321098765432109876543210
   6770                                              xxxxxxxxxxxx1010xxxxxxxx111111xx
   6771                                              sli.  */
   6772                                           return 484;
   6773                                         }
   6774                                     }
   6775                                   else
   6776                                     {
   6777                                       if (((word >> 14) & 0x1) == 0)
   6778                                         {
   6779                                           /* 33222222222211111111110000000000
   6780                                              10987654321098765432109876543210
   6781                                              xxxxxxxxxxxx1100xxxxxxxx111111xx
   6782                                              ursra.  */
   6783                                           return 482;
   6784                                         }
   6785                                       else
   6786                                         {
   6787                                           /* 33222222222211111111110000000000
   6788                                              10987654321098765432109876543210
   6789                                              xxxxxxxxxxxx1110xxxxxxxx111111xx
   6790                                              uqshl.  */
   6791                                           return 486;
   6792                                         }
   6793                                     }
   6794                                 }
   6795                             }
   6796                         }
   6797                     }
   6798                   else
   6799                     {
   6800                       if (((word >> 28) & 0x1) == 0)
   6801                         {
   6802                           if (((word >> 10) & 0x1) == 0)
   6803                             {
   6804                               if (((word >> 12) & 0x1) == 0)
   6805                                 {
   6806                                   if (((word >> 13) & 0x1) == 0)
   6807                                     {
   6808                                       if (((word >> 14) & 0x1) == 0)
   6809                                         {
   6810                                           /* 33222222222211111111110000000000
   6811                                              10987654321098765432109876543210
   6812                                              xxxxxxxxxx0x0001xxxxxxxx11110xxx
   6813                                              mul.  */
   6814                                           return 100;
   6815                                         }
   6816                                       else
   6817                                         {
   6818                                           /* 33222222222211111111110000000000
   6819                                              10987654321098765432109876543210
   6820                                              xxxxxxxxxx0x0011xxxxxxxx11110xxx
   6821                                              sqdmulh.  */
   6822                                           return 105;
   6823                                         }
   6824                                     }
   6825                                   else
   6826                                     {
   6827                                       if (((word >> 29) & 0x1) == 0)
   6828                                         {
   6829                                           if (((word >> 30) & 0x1) == 0)
   6830                                             {
   6831                                               /* 33222222222211111111110000000000
   6832                                                  10987654321098765432109876543210
   6833                                                  xxxxxxxxxx0x01x1xxxxxxxx1111000x
   6834                                                  smull.  */
   6835                                               return 101;
   6836                                             }
   6837                                           else
   6838                                             {
   6839                                               /* 33222222222211111111110000000000
   6840                                                  10987654321098765432109876543210
   6841                                                  xxxxxxxxxx0x01x1xxxxxxxx1111001x
   6842                                                  smull2.  */
   6843                                               return 102;
   6844                                             }
   6845                                         }
   6846                                       else
   6847                                         {
   6848                                           if (((word >> 30) & 0x1) == 0)
   6849                                             {
   6850                                               /* 33222222222211111111110000000000
   6851                                                  10987654321098765432109876543210
   6852                                                  xxxxxxxxxx0x01x1xxxxxxxx1111010x
   6853                                                  umull.  */
   6854                                               return 116;
   6855                                             }
   6856                                           else
   6857                                             {
   6858                                               /* 33222222222211111111110000000000
   6859                                                  10987654321098765432109876543210
   6860                                                  xxxxxxxxxx0x01x1xxxxxxxx1111011x
   6861                                                  umull2.  */
   6862                                               return 117;
   6863                                             }
   6864                                         }
   6865                                     }
   6866                                 }
   6867                               else
   6868                                 {
   6869                                   if (((word >> 13) & 0x1) == 0)
   6870                                     {
   6871                                       if (((word >> 14) & 0x1) == 0)
   6872                                         {
   6873                                           if (((word >> 29) & 0x1) == 0)
   6874                                             {
   6875                                               /* 33222222222211111111110000000000
   6876                                                  10987654321098765432109876543210
   6877                                                  xxxxxxxxxx0x1001xxxxxxxx111100xx
   6878                                                  fmul.  */
   6879                                               return 109;
   6880                                             }
   6881                                           else
   6882                                             {
   6883                                               /* 33222222222211111111110000000000
   6884                                                  10987654321098765432109876543210
   6885                                                  xxxxxxxxxx0x1001xxxxxxxx111101xx
   6886                                                  fmulx.  */
   6887                                               return 118;
   6888                                             }
   6889                                         }
   6890                                       else
   6891                                         {
   6892                                           /* 33222222222211111111110000000000
   6893                                              10987654321098765432109876543210
   6894                                              xxxxxxxxxx0x1011xxxxxxxx11110xxx
   6895                                              sqrdmulh.  */
   6896                                           return 106;
   6897                                         }
   6898                                     }
   6899                                   else
   6900                                     {
   6901                                       if (((word >> 30) & 0x1) == 0)
   6902                                         {
   6903                                           /* 33222222222211111111110000000000
   6904                                              10987654321098765432109876543210
   6905                                              xxxxxxxxxx0x11x1xxxxxxxx11110x0x
   6906                                              sqdmull.  */
   6907                                           return 103;
   6908                                         }
   6909                                       else
   6910                                         {
   6911                                           /* 33222222222211111111110000000000
   6912                                              10987654321098765432109876543210
   6913                                              xxxxxxxxxx0x11x1xxxxxxxx11110x1x
   6914                                              sqdmull2.  */
   6915                                           return 104;
   6916                                         }
   6917                                     }
   6918                                 }
   6919                             }
   6920                           else
   6921                             {
   6922                               if (((word >> 11) & 0x1) == 0)
   6923                                 {
   6924                                   if (((word >> 14) & 0x1) == 0)
   6925                                     {
   6926                                       if (((word >> 12) & 0x1) == 0)
   6927                                         {
   6928                                           if (((word >> 29) & 0x1) == 0)
   6929                                             {
   6930                                               /* 33222222222211111111110000000000
   6931                                                  10987654321098765432109876543210
   6932                                                  xxxxxxxxxx100x01xxxxxxxx111100xx
   6933                                                  movi.  */
   6934                                               return 122;
   6935                                             }
   6936                                           else
   6937                                             {
   6938                                               /* 33222222222211111111110000000000
   6939                                                  10987654321098765432109876543210
   6940                                                  xxxxxxxxxx100x01xxxxxxxx111101xx
   6941                                                  mvni.  */
   6942                                               return 129;
   6943                                             }
   6944                                         }
   6945                                       else
   6946                                         {
   6947                                           if (((word >> 29) & 0x1) == 0)
   6948                                             {
   6949                                               /* 33222222222211111111110000000000
   6950                                                  10987654321098765432109876543210
   6951                                                  xxxxxxxxxx101x01xxxxxxxx111100xx
   6952                                                  orr.  */
   6953                                               return 123;
   6954                                             }
   6955                                           else
   6956                                             {
   6957                                               /* 33222222222211111111110000000000
   6958                                                  10987654321098765432109876543210
   6959                                                  xxxxxxxxxx101x01xxxxxxxx111101xx
   6960                                                  bic.  */
   6961                                               return 130;
   6962                                             }
   6963                                         }
   6964                                     }
   6965                                   else
   6966                                     {
   6967                                       if (((word >> 13) & 0x1) == 0)
   6968                                         {
   6969                                           if (((word >> 29) & 0x1) == 0)
   6970                                             {
   6971                                               /* 33222222222211111111110000000000
   6972                                                  10987654321098765432109876543210
   6973                                                  xxxxxxxxxx10x011xxxxxxxx111100xx
   6974                                                  movi.  */
   6975                                               return 124;
   6976                                             }
   6977                                           else
   6978                                             {
   6979                                               /* 33222222222211111111110000000000
   6980                                                  10987654321098765432109876543210
   6981                                                  xxxxxxxxxx10x011xxxxxxxx111101xx
   6982                                                  mvni.  */
   6983                                               return 131;
   6984                                             }
   6985                                         }
   6986                                       else
   6987                                         {
   6988                                           if (((word >> 12) & 0x1) == 0)
   6989                                             {
   6990                                               if (((word >> 29) & 0x1) == 0)
   6991                                                 {
   6992                                                   /* 33222222222211111111110000000000
   6993                                                      10987654321098765432109876543210
   6994                                                      xxxxxxxxxx100111xxxxxxxx111100xx
   6995                                                      movi.  */
   6996                                                   return 125;
   6997                                                 }
   6998                                               else
   6999                                                 {
   7000                                                   /* 33222222222211111111110000000000
   7001                                                      10987654321098765432109876543210
   7002                                                      xxxxxxxxxx100111xxxxxxxx111101xx
   7003                                                      movi.  */
   7004                                                   return 132;
   7005                                                 }
   7006                                             }
   7007                                           else
   7008                                             {
   7009                                               if (((word >> 29) & 0x1) == 0)
   7010                                                 {
   7011                                                   /* 33222222222211111111110000000000
   7012                                                      10987654321098765432109876543210
   7013                                                      xxxxxxxxxx101111xxxxxxxx111100xx
   7014                                                      fmov.  */
   7015                                                   return 126;
   7016                                                 }
   7017                                               else
   7018                                                 {
   7019                                                   /* 33222222222211111111110000000000
   7020                                                      10987654321098765432109876543210
   7021                                                      xxxxxxxxxx101111xxxxxxxx111101xx
   7022                                                      fmov.  */
   7023                                                   return 134;
   7024                                                 }
   7025                                             }
   7026                                         }
   7027                                     }
   7028                                 }
   7029                               else
   7030                                 {
   7031                                   if (((word >> 12) & 0x1) == 0)
   7032                                     {
   7033                                       if (((word >> 29) & 0x1) == 0)
   7034                                         {
   7035                                           if (((word >> 30) & 0x1) == 0)
   7036                                             {
   7037                                               /* 33222222222211111111110000000000
   7038                                                  10987654321098765432109876543210
   7039                                                  xxxxxxxxxx110xx1xxxxxxxx1111000x
   7040                                                  rshrn.  */
   7041                                               return 307;
   7042                                             }
   7043                                           else
   7044                                             {
   7045                                               /* 33222222222211111111110000000000
   7046                                                  10987654321098765432109876543210
   7047                                                  xxxxxxxxxx110xx1xxxxxxxx1111001x
   7048                                                  rshrn2.  */
   7049                                               return 308;
   7050                                             }
   7051                                         }
   7052                                       else
   7053                                         {
   7054                                           if (((word >> 30) & 0x1) == 0)
   7055                                             {
   7056                                               /* 33222222222211111111110000000000
   7057                                                  10987654321098765432109876543210
   7058                                                  xxxxxxxxxx110xx1xxxxxxxx1111010x
   7059                                                  sqrshrun.  */
   7060                                               return 329;
   7061                                             }
   7062                                           else
   7063                                             {
   7064                                               /* 33222222222211111111110000000000
   7065                                                  10987654321098765432109876543210
   7066                                                  xxxxxxxxxx110xx1xxxxxxxx1111011x
   7067                                                  sqrshrun2.  */
   7068                                               return 330;
   7069                                             }
   7070                                         }
   7071                                     }
   7072                                   else
   7073                                     {
   7074                                       if (((word >> 13) & 0x1) == 0)
   7075                                         {
   7076                                           if (((word >> 29) & 0x1) == 0)
   7077                                             {
   7078                                               if (((word >> 30) & 0x1) == 0)
   7079                                                 {
   7080                                                   /* 33222222222211111111110000000000
   7081                                                      10987654321098765432109876543210
   7082                                                      xxxxxxxxxx1110x1xxxxxxxx1111000x
   7083                                                      sqrshrn.  */
   7084                                                   return 311;
   7085                                                 }
   7086                                               else
   7087                                                 {
   7088                                                   /* 33222222222211111111110000000000
   7089                                                      10987654321098765432109876543210
   7090                                                      xxxxxxxxxx1110x1xxxxxxxx1111001x
   7091                                                      sqrshrn2.  */
   7092                                                   return 312;
   7093                                                 }
   7094                                             }
   7095                                           else
   7096                                             {
   7097                                               if (((word >> 30) & 0x1) == 0)
   7098                                                 {
   7099                                                   /* 33222222222211111111110000000000
   7100                                                      10987654321098765432109876543210
   7101                                                      xxxxxxxxxx1110x1xxxxxxxx1111010x
   7102                                                      uqrshrn.  */
   7103                                                   return 333;
   7104                                                 }
   7105                                               else
   7106                                                 {
   7107                                                   /* 33222222222211111111110000000000
   7108                                                      10987654321098765432109876543210
   7109                                                      xxxxxxxxxx1110x1xxxxxxxx1111011x
   7110                                                      uqrshrn2.  */
   7111                                                   return 334;
   7112                                                 }
   7113                                             }
   7114                                         }
   7115                                       else
   7116                                         {
   7117                                           if (((word >> 29) & 0x1) == 0)
   7118                                             {
   7119                                               /* 33222222222211111111110000000000
   7120                                                  10987654321098765432109876543210
   7121                                                  xxxxxxxxxx1111x1xxxxxxxx111100xx
   7122                                                  fcvtzs.  */
   7123                                               return 318;
   7124                                             }
   7125                                           else
   7126                                             {
   7127                                               /* 33222222222211111111110000000000
   7128                                                  10987654321098765432109876543210
   7129                                                  xxxxxxxxxx1111x1xxxxxxxx111101xx
   7130                                                  fcvtzu.  */
   7131                                               return 340;
   7132                                             }
   7133                                         }
   7134                                     }
   7135                                 }
   7136                             }
   7137                         }
   7138                       else
   7139                         {
   7140                           if (((word >> 29) & 0x1) == 0)
   7141                             {
   7142                               if (((word >> 30) & 0x1) == 0)
   7143                                 {
   7144                                   if (((word >> 21) & 0x1) == 0)
   7145                                     {
   7146                                       /* 33222222222211111111110000000000
   7147                                          10987654321098765432109876543210
   7148                                          xxxxxxxxxxxxxxx1xxxxx0xx1111100x
   7149                                          fmsub.  */
   7150                                       return 636;
   7151                                     }
   7152                                   else
   7153                                     {
   7154                                       /* 33222222222211111111110000000000
   7155                                          10987654321098765432109876543210
   7156                                          xxxxxxxxxxxxxxx1xxxxx1xx1111100x
   7157                                          fnmsub.  */
   7158                                       return 638;
   7159                                     }
   7160                                 }
   7161                               else
   7162                                 {
   7163                                   if (((word >> 10) & 0x1) == 0)
   7164                                     {
   7165                                       if (((word >> 12) & 0x1) == 0)
   7166                                         {
   7167                                           /* 33222222222211111111110000000000
   7168                                              10987654321098765432109876543210
   7169                                              xxxxxxxxxx0x0xx1xxxxxxxx1111101x
   7170                                              sqdmulh.  */
   7171                                           return 349;
   7172                                         }
   7173                                       else
   7174                                         {
   7175                                           if (((word >> 13) & 0x1) == 0)
   7176                                             {
   7177                                               if (((word >> 14) & 0x1) == 0)
   7178                                                 {
   7179                                                   /* 33222222222211111111110000000000
   7180                                                      10987654321098765432109876543210
   7181                                                      xxxxxxxxxx0x1001xxxxxxxx1111101x
   7182                                                      fmul.  */
   7183                                                   return 353;
   7184                                                 }
   7185                                               else
   7186                                                 {
   7187                                                   /* 33222222222211111111110000000000
   7188                                                      10987654321098765432109876543210
   7189                                                      xxxxxxxxxx0x1011xxxxxxxx1111101x
   7190                                                      sqrdmulh.  */
   7191                                                   return 350;
   7192                                                 }
   7193                                             }
   7194                                           else
   7195                                             {
   7196                                               /* 33222222222211111111110000000000
   7197                                                  10987654321098765432109876543210
   7198                                                  xxxxxxxxxx0x11x1xxxxxxxx1111101x
   7199                                                  sqdmull.  */
   7200                                               return 348;
   7201                                             }
   7202                                         }
   7203                                     }
   7204                                   else
   7205                                     {
   7206                                       if (((word >> 11) & 0x1) == 0)
   7207                                         {
   7208                                           if (((word >> 12) & 0x1) == 0)
   7209                                             {
   7210                                               /* 33222222222211111111110000000000
   7211                                                  10987654321098765432109876543210
   7212                                                  xxxxxxxxxx100xx1xxxxxxxx1111101x
   7213                                                  scvtf.  */
   7214                                               return 477;
   7215                                             }
   7216                                           else
   7217                                             {
   7218                                               /* 33222222222211111111110000000000
   7219                                                  10987654321098765432109876543210
   7220                                                  xxxxxxxxxx101xx1xxxxxxxx1111101x
   7221                                                  sqshrn.  */
   7222                                               return 475;
   7223                                             }
   7224                                         }
   7225                                       else
   7226                                         {
   7227                                           if (((word >> 13) & 0x1) == 0)
   7228                                             {
   7229                                               /* 33222222222211111111110000000000
   7230                                                  10987654321098765432109876543210
   7231                                                  xxxxxxxxxx11x0x1xxxxxxxx1111101x
   7232                                                  sqrshrn.  */
   7233                                               return 476;
   7234                                             }
   7235                                           else
   7236                                             {
   7237                                               /* 33222222222211111111110000000000
   7238                                                  10987654321098765432109876543210
   7239                                                  xxxxxxxxxx11x1x1xxxxxxxx1111101x
   7240                                                  fcvtzs.  */
   7241                                               return 478;
   7242                                             }
   7243                                         }
   7244                                     }
   7245                                 }
   7246                             }
   7247                           else
   7248                             {
   7249                               if (((word >> 10) & 0x1) == 0)
   7250                                 {
   7251                                   /* 33222222222211111111110000000000
   7252                                      10987654321098765432109876543210
   7253                                      xxxxxxxxxx0xxxx1xxxxxxxx111111xx
   7254                                      fmulx.  */
   7255                                   return 354;
   7256                                 }
   7257                               else
   7258                                 {
   7259                                   if (((word >> 11) & 0x1) == 0)
   7260                                     {
   7261                                       if (((word >> 12) & 0x1) == 0)
   7262                                         {
   7263                                           if (((word >> 13) & 0x1) == 0)
   7264                                             {
   7265                                               /* 33222222222211111111110000000000
   7266                                                  10987654321098765432109876543210
   7267                                                  xxxxxxxxxx1000x1xxxxxxxx111111xx
   7268                                                  sqshrun.  */
   7269                                               return 487;
   7270                                             }
   7271                                           else
   7272                                             {
   7273                                               /* 33222222222211111111110000000000
   7274                                                  10987654321098765432109876543210
   7275                                                  xxxxxxxxxx1001x1xxxxxxxx111111xx
   7276                                                  ucvtf.  */
   7277                                               return 491;
   7278                                             }
   7279                                         }
   7280                                       else
   7281                                         {
   7282                                           /* 33222222222211111111110000000000
   7283                                              10987654321098765432109876543210
   7284                                              xxxxxxxxxx101xx1xxxxxxxx111111xx
   7285                                              uqshrn.  */
   7286                                           return 489;
   7287                                         }
   7288                                     }
   7289                                   else
   7290                                     {
   7291                                       if (((word >> 12) & 0x1) == 0)
   7292                                         {
   7293                                           /* 33222222222211111111110000000000
   7294                                              10987654321098765432109876543210
   7295                                              xxxxxxxxxx110xx1xxxxxxxx111111xx
   7296                                              sqrshrun.  */
   7297                                           return 488;
   7298                                         }
   7299                                       else
   7300                                         {
   7301                                           if (((word >> 13) & 0x1) == 0)
   7302                                             {
   7303                                               /* 33222222222211111111110000000000
   7304                                                  10987654321098765432109876543210
   7305                                                  xxxxxxxxxx1110x1xxxxxxxx111111xx
   7306                                                  uqrshrn.  */
   7307                                               return 490;
   7308                                             }
   7309                                           else
   7310                                             {
   7311                                               /* 33222222222211111111110000000000
   7312                                                  10987654321098765432109876543210
   7313                                                  xxxxxxxxxx1111x1xxxxxxxx111111xx
   7314                                                  fcvtzu.  */
   7315                                               return 492;
   7316                                             }
   7317                                         }
   7318                                     }
   7319                                 }
   7320                             }
   7321                         }
   7322                     }
   7323                 }
   7324             }
   7325         }
   7326     }
   7327 }
   7328 
   7329 /* Lookup opcode WORD in the opcode table.  N.B. all alias
   7330    opcodes are ignored here.  */
   7331 
   7332 const aarch64_opcode *
   7333 aarch64_opcode_lookup (uint32_t word)
   7334 {
   7335   return aarch64_opcode_table + aarch64_opcode_lookup_1 (word);
   7336 }
   7337 
   7338 const aarch64_opcode *
   7339 aarch64_find_next_opcode (const aarch64_opcode *opcode)
   7340 {
   7341   /* Use the index as the key to locate the next opcode.  */
   7342   int key = opcode - aarch64_opcode_table;
   7343   int value;
   7344   switch (key)
   7345     {
   7346     case 731: value = 735; break;	/* stnp --> stp.  */
   7347     case 735: return NULL;		/* stp --> NULL.  */
   7348     case 732: value = 736; break;	/* ldnp --> ldp.  */
   7349     case 736: return NULL;		/* ldp --> NULL.  */
   7350     case 355: value = 356; break;	/* st4 --> st1.  */
   7351     case 356: value = 357; break;	/* st1 --> st2.  */
   7352     case 357: value = 358; break;	/* st2 --> st3.  */
   7353     case 358: return NULL;		/* st3 --> NULL.  */
   7354     case 363: value = 364; break;	/* st4 --> st1.  */
   7355     case 364: value = 365; break;	/* st1 --> st2.  */
   7356     case 365: value = 366; break;	/* st2 --> st3.  */
   7357     case 366: return NULL;		/* st3 --> NULL.  */
   7358     case 359: value = 360; break;	/* ld4 --> ld1.  */
   7359     case 360: value = 361; break;	/* ld1 --> ld2.  */
   7360     case 361: value = 362; break;	/* ld2 --> ld3.  */
   7361     case 362: return NULL;		/* ld3 --> NULL.  */
   7362     case 375: value = 377; break;	/* ld1 --> ld1r.  */
   7363     case 377: return NULL;		/* ld1r --> NULL.  */
   7364     case 379: value = 381; break;	/* ld2 --> ld2r.  */
   7365     case 381: return NULL;		/* ld2r --> NULL.  */
   7366     case 376: value = 378; break;	/* ld3 --> ld3r.  */
   7367     case 378: return NULL;		/* ld3r --> NULL.  */
   7368     case 380: value = 382; break;	/* ld4 --> ld4r.  */
   7369     case 382: return NULL;		/* ld4r --> NULL.  */
   7370     case 367: value = 368; break;	/* ld4 --> ld1.  */
   7371     case 368: value = 369; break;	/* ld1 --> ld2.  */
   7372     case 369: value = 370; break;	/* ld2 --> ld3.  */
   7373     case 370: return NULL;		/* ld3 --> NULL.  */
   7374     case 387: value = 389; break;	/* ld1 --> ld1r.  */
   7375     case 389: return NULL;		/* ld1r --> NULL.  */
   7376     case 388: value = 390; break;	/* ld3 --> ld3r.  */
   7377     case 390: return NULL;		/* ld3r --> NULL.  */
   7378     case 391: value = 393; break;	/* ld2 --> ld2r.  */
   7379     case 393: return NULL;		/* ld2r --> NULL.  */
   7380     case 392: value = 394; break;	/* ld4 --> ld4r.  */
   7381     case 394: return NULL;		/* ld4r --> NULL.  */
   7382     case 120: value = 299; break;	/* movi --> sshr.  */
   7383     case 299: value = 301; break;	/* sshr --> srshr.  */
   7384     case 301: return NULL;		/* srshr --> NULL.  */
   7385     case 127: value = 319; break;	/* mvni --> ushr.  */
   7386     case 319: value = 321; break;	/* ushr --> urshr.  */
   7387     case 321: value = 323; break;	/* urshr --> sri.  */
   7388     case 323: value = 325; break;	/* sri --> sqshlu.  */
   7389     case 325: return NULL;		/* sqshlu --> NULL.  */
   7390     case 121: value = 300; break;	/* orr --> ssra.  */
   7391     case 300: value = 302; break;	/* ssra --> srsra.  */
   7392     case 302: value = 303; break;	/* srsra --> shl.  */
   7393     case 303: value = 304; break;	/* shl --> sqshl.  */
   7394     case 304: return NULL;		/* sqshl --> NULL.  */
   7395     case 128: value = 320; break;	/* bic --> usra.  */
   7396     case 320: value = 322; break;	/* usra --> ursra.  */
   7397     case 322: value = 324; break;	/* ursra --> sli.  */
   7398     case 324: value = 326; break;	/* sli --> uqshl.  */
   7399     case 326: return NULL;		/* uqshl --> NULL.  */
   7400     case 122: value = 305; break;	/* movi --> shrn.  */
   7401     case 305: value = 306; break;	/* shrn --> shrn2.  */
   7402     case 306: value = 313; break;	/* shrn2 --> sshll.  */
   7403     case 313: value = 315; break;	/* sshll --> sshll2.  */
   7404     case 315: return NULL;		/* sshll2 --> NULL.  */
   7405     case 129: value = 327; break;	/* mvni --> sqshrun.  */
   7406     case 327: value = 328; break;	/* sqshrun --> sqshrun2.  */
   7407     case 328: value = 335; break;	/* sqshrun2 --> ushll.  */
   7408     case 335: value = 337; break;	/* ushll --> ushll2.  */
   7409     case 337: return NULL;		/* ushll2 --> NULL.  */
   7410     case 123: value = 309; break;	/* orr --> sqshrn.  */
   7411     case 309: value = 310; break;	/* sqshrn --> sqshrn2.  */
   7412     case 310: return NULL;		/* sqshrn2 --> NULL.  */
   7413     case 130: value = 331; break;	/* bic --> uqshrn.  */
   7414     case 331: value = 332; break;	/* uqshrn --> uqshrn2.  */
   7415     case 332: return NULL;		/* uqshrn2 --> NULL.  */
   7416     case 125: value = 317; break;	/* movi --> scvtf.  */
   7417     case 317: return NULL;		/* scvtf --> NULL.  */
   7418     case 132: value = 133; break;	/* movi --> movi.  */
   7419     case 133: value = 339; break;	/* movi --> ucvtf.  */
   7420     case 339: return NULL;		/* ucvtf --> NULL.  */
   7421     default: return NULL;
   7422     }
   7423 
   7424   return aarch64_opcode_table + value;
   7425 }
   7426 
   7427 const aarch64_opcode *
   7428 aarch64_find_alias_opcode (const aarch64_opcode *opcode)
   7429 {
   7430   /* Use the index as the key to locate the alias opcode.  */
   7431   int key = opcode - aarch64_opcode_table;
   7432   int value;
   7433   switch (key)
   7434     {
   7435     case 2: value = 3; break;	/* sbc --> ngc.  */
   7436     case 4: value = 5; break;	/* sbcs --> ngcs.  */
   7437     case 7: value = 8; break;	/* adds --> cmn.  */
   7438     case 10: value = 11; break;	/* subs --> cmp.  */
   7439     case 12: value = 13; break;	/* add --> mov.  */
   7440     case 14: value = 15; break;	/* adds --> cmn.  */
   7441     case 17: value = 18; break;	/* subs --> cmp.  */
   7442     case 20: value = 21; break;	/* adds --> cmn.  */
   7443     case 22: value = 23; break;	/* sub --> neg.  */
   7444     case 24: value = 26; break;	/* subs --> negs.  */
   7445     case 138: value = 139; break;	/* umov --> mov.  */
   7446     case 140: value = 141; break;	/* ins --> mov.  */
   7447     case 142: value = 143; break;	/* ins --> mov.  */
   7448     case 203: value = 204; break;	/* not --> mvn.  */
   7449     case 258: value = 259; break;	/* orr --> mov.  */
   7450     case 313: value = 314; break;	/* sshll --> sxtl.  */
   7451     case 315: value = 316; break;	/* sshll2 --> sxtl2.  */
   7452     case 335: value = 336; break;	/* ushll --> uxtl.  */
   7453     case 337: value = 338; break;	/* ushll2 --> uxtl2.  */
   7454     case 430: value = 431; break;	/* dup --> mov.  */
   7455     case 493: value = 498; break;	/* sbfm --> sxtw.  */
   7456     case 500: value = 502; break;	/* bfm --> bfxil.  */
   7457     case 503: value = 507; break;	/* ubfm --> uxth.  */
   7458     case 525: value = 527; break;	/* csinc --> cset.  */
   7459     case 528: value = 530; break;	/* csinv --> csetm.  */
   7460     case 531: value = 532; break;	/* csneg --> cneg.  */
   7461     case 556: value = 557; break;	/* lslv --> lsl.  */
   7462     case 558: value = 559; break;	/* lsrv --> lsr.  */
   7463     case 560: value = 561; break;	/* asrv --> asr.  */
   7464     case 562: value = 563; break;	/* rorv --> ror.  */
   7465     case 564: value = 565; break;	/* madd --> mul.  */
   7466     case 566: value = 567; break;	/* msub --> mneg.  */
   7467     case 568: value = 569; break;	/* smaddl --> smull.  */
   7468     case 570: value = 571; break;	/* smsubl --> smnegl.  */
   7469     case 573: value = 574; break;	/* umaddl --> umull.  */
   7470     case 575: value = 576; break;	/* umsubl --> umnegl.  */
   7471     case 586: value = 587; break;	/* extr --> ror.  */
   7472     case 685: value = 687; break;	/* sturb --> strb.  */
   7473     case 686: value = 688; break;	/* ldurb --> ldrb.  */
   7474     case 689: value = 690; break;	/* ldursb --> ldrsb.  */
   7475     case 691: value = 693; break;	/* stur --> str.  */
   7476     case 692: value = 694; break;	/* ldur --> ldr.  */
   7477     case 695: value = 697; break;	/* sturh --> strh.  */
   7478     case 696: value = 698; break;	/* ldurh --> ldrh.  */
   7479     case 699: value = 700; break;	/* ldursh --> ldrsh.  */
   7480     case 701: value = 703; break;	/* stur --> str.  */
   7481     case 702: value = 704; break;	/* ldur --> ldr.  */
   7482     case 705: value = 706; break;	/* ldursw --> ldrsw.  */
   7483     case 707: value = 708; break;	/* prfum --> prfm.  */
   7484     case 749: value = 750; break;	/* and --> bic.  */
   7485     case 751: value = 752; break;	/* orr --> mov.  */
   7486     case 754: value = 755; break;	/* ands --> tst.  */
   7487     case 758: value = 760; break;	/* orr --> uxtw.  */
   7488     case 761: value = 762; break;	/* orn --> mvn.  */
   7489     case 765: value = 766; break;	/* ands --> tst.  */
   7490     case 768: value = 769; break;	/* movn --> mov.  */
   7491     case 770: value = 771; break;	/* movz --> mov.  */
   7492     case 776: value = 782; break;	/* hint --> sevl.  */
   7493     case 787: value = 791; break;	/* sys --> tlbi.  */
   7494     default: return NULL;
   7495     }
   7496 
   7497   return aarch64_opcode_table + value;
   7498 }
   7499 
   7500 const aarch64_opcode *
   7501 aarch64_find_next_alias_opcode (const aarch64_opcode *opcode)
   7502 {
   7503   /* Use the index as the key to locate the next opcode.  */
   7504   int key = opcode - aarch64_opcode_table;
   7505   int value;
   7506   switch (key)
   7507     {
   7508     case 26: value = 25; break;	/* negs --> cmp.  */
   7509     case 498: value = 497; break;	/* sxtw --> sxth.  */
   7510     case 497: value = 496; break;	/* sxth --> sxtb.  */
   7511     case 496: value = 499; break;	/* sxtb --> asr.  */
   7512     case 499: value = 495; break;	/* asr --> sbfx.  */
   7513     case 495: value = 494; break;	/* sbfx --> sbfiz.  */
   7514     case 502: value = 501; break;	/* bfxil --> bfi.  */
   7515     case 507: value = 506; break;	/* uxth --> uxtb.  */
   7516     case 506: value = 509; break;	/* uxtb --> lsr.  */
   7517     case 509: value = 508; break;	/* lsr --> lsl.  */
   7518     case 508: value = 505; break;	/* lsl --> ubfx.  */
   7519     case 505: value = 504; break;	/* ubfx --> ubfiz.  */
   7520     case 527: value = 526; break;	/* cset --> cinc.  */
   7521     case 530: value = 529; break;	/* csetm --> cinv.  */
   7522     case 760: value = 759; break;	/* uxtw --> mov.  */
   7523     case 782: value = 781; break;	/* sevl --> sev.  */
   7524     case 781: value = 780; break;	/* sev --> wfi.  */
   7525     case 780: value = 779; break;	/* wfi --> wfe.  */
   7526     case 779: value = 778; break;	/* wfe --> yield.  */
   7527     case 778: value = 777; break;	/* yield --> nop.  */
   7528     case 791: value = 790; break;	/* tlbi --> ic.  */
   7529     case 790: value = 789; break;	/* ic --> dc.  */
   7530     case 789: value = 788; break;	/* dc --> at.  */
   7531     default: return NULL;
   7532     }
   7533 
   7534   return aarch64_opcode_table + value;
   7535 }
   7536 
   7537 int
   7538 aarch64_extract_operand (const aarch64_operand *self,
   7539 			   aarch64_opnd_info *info,
   7540 			   aarch64_insn code, const aarch64_inst *inst)
   7541 {
   7542   /* Use the index as the key.  */
   7543   int key = self - aarch64_operands;
   7544   switch (key)
   7545     {
   7546     case 1:
   7547     case 2:
   7548     case 3:
   7549     case 4:
   7550     case 5:
   7551     case 6:
   7552     case 7:
   7553     case 9:
   7554     case 10:
   7555     case 13:
   7556     case 14:
   7557     case 15:
   7558     case 16:
   7559     case 18:
   7560     case 19:
   7561     case 20:
   7562     case 21:
   7563     case 22:
   7564     case 23:
   7565     case 24:
   7566     case 25:
   7567     case 26:
   7568     case 34:
   7569     case 35:
   7570       return aarch64_ext_regno (self, info, code, inst);
   7571     case 8:
   7572       return aarch64_ext_regrt_sysins (self, info, code, inst);
   7573     case 11:
   7574       return aarch64_ext_reg_extended (self, info, code, inst);
   7575     case 12:
   7576       return aarch64_ext_reg_shifted (self, info, code, inst);
   7577     case 17:
   7578       return aarch64_ext_ft (self, info, code, inst);
   7579     case 27:
   7580     case 28:
   7581     case 29:
   7582       return aarch64_ext_reglane (self, info, code, inst);
   7583     case 30:
   7584       return aarch64_ext_reglist (self, info, code, inst);
   7585     case 31:
   7586       return aarch64_ext_ldst_reglist (self, info, code, inst);
   7587     case 32:
   7588       return aarch64_ext_ldst_reglist_r (self, info, code, inst);
   7589     case 33:
   7590       return aarch64_ext_ldst_elemlist (self, info, code, inst);
   7591     case 36:
   7592     case 45:
   7593     case 46:
   7594     case 47:
   7595     case 48:
   7596     case 49:
   7597     case 50:
   7598     case 51:
   7599     case 52:
   7600     case 53:
   7601     case 54:
   7602     case 55:
   7603     case 56:
   7604     case 57:
   7605     case 64:
   7606     case 65:
   7607     case 66:
   7608     case 67:
   7609     case 68:
   7610       return aarch64_ext_imm (self, info, code, inst);
   7611     case 37:
   7612     case 38:
   7613       return aarch64_ext_advsimd_imm_shift (self, info, code, inst);
   7614     case 39:
   7615     case 40:
   7616     case 41:
   7617       return aarch64_ext_advsimd_imm_modified (self, info, code, inst);
   7618     case 42:
   7619       return aarch64_ext_shll_imm (self, info, code, inst);
   7620     case 58:
   7621       return aarch64_ext_limm (self, info, code, inst);
   7622     case 59:
   7623       return aarch64_ext_aimm (self, info, code, inst);
   7624     case 60:
   7625       return aarch64_ext_imm_half (self, info, code, inst);
   7626     case 61:
   7627       return aarch64_ext_fbits (self, info, code, inst);
   7628     case 63:
   7629       return aarch64_ext_cond (self, info, code, inst);
   7630     case 69:
   7631     case 75:
   7632       return aarch64_ext_addr_simple (self, info, code, inst);
   7633     case 70:
   7634       return aarch64_ext_addr_regoff (self, info, code, inst);
   7635     case 71:
   7636     case 72:
   7637     case 73:
   7638       return aarch64_ext_addr_simm (self, info, code, inst);
   7639     case 74:
   7640       return aarch64_ext_addr_uimm12 (self, info, code, inst);
   7641     case 76:
   7642       return aarch64_ext_simd_addr_post (self, info, code, inst);
   7643     case 77:
   7644       return aarch64_ext_sysreg (self, info, code, inst);
   7645     case 78:
   7646       return aarch64_ext_pstatefield (self, info, code, inst);
   7647     case 79:
   7648     case 80:
   7649     case 81:
   7650     case 82:
   7651       return aarch64_ext_sysins_op (self, info, code, inst);
   7652     case 83:
   7653     case 84:
   7654       return aarch64_ext_barrier (self, info, code, inst);
   7655     case 85:
   7656       return aarch64_ext_prfop (self, info, code, inst);
   7657     default: assert (0); abort ();
   7658     }
   7659 }
   7660