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