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