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