Home | History | Annotate | Line # | Download | only in opcodes
aarch64-dis-2.c revision 1.7
      1 /* This file is automatically generated by aarch64-gen.  Do not edit!  */
      2 /* Copyright (C) 2012-2017 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 1155;
     44                     }
     45                   else
     46                     {
     47                       /* 33222222222211111111110000000000
     48                          10987654321098765432109876543210
     49                          xxxxxxxxxxxxxxxxxxxxxxxx0000xxx1
     50                          adrp.  */
     51                       return 1156;
     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 910;
    119                                             }
    120                                           else
    121                                             {
    122                                               /* 33222222222211111111110000000000
    123                                                  10987654321098765432109876543210
    124                                                  xxxxxxxxxxxxxxx0xxxxx000x0010010
    125                                                  stxrh.  */
    126                                               return 916;
    127                                             }
    128                                         }
    129                                       else
    130                                         {
    131                                           /* 33222222222211111111110000000000
    132                                              10987654321098765432109876543210
    133                                              xxxxxxxxxxxxxxx0xxxxx000x00100x1
    134                                              stxr.  */
    135                                           return 922;
    136                                         }
    137                                     }
    138                                   else
    139                                     {
    140                                       if (((word >> 31) & 0x1) == 0)
    141                                         {
    142                                           /* 33222222222211111111110000000000
    143                                              10987654321098765432109876543210
    144                                              xxxxxxxxxxxxxxx0xxxxx100x00100x0
    145                                              casp.  */
    146                                           return 990;
    147                                         }
    148                                       else
    149                                         {
    150                                           /* 33222222222211111111110000000000
    151                                              10987654321098765432109876543210
    152                                              xxxxxxxxxxxxxxx0xxxxx100x00100x1
    153                                              stxp.  */
    154                                           return 924;
    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 911;
    171                                             }
    172                                           else
    173                                             {
    174                                               /* 33222222222211111111110000000000
    175                                                  10987654321098765432109876543210
    176                                                  xxxxxxxxxxxxxxx1xxxxx000x0010010
    177                                                  stlxrh.  */
    178                                               return 917;
    179                                             }
    180                                         }
    181                                       else
    182                                         {
    183                                           /* 33222222222211111111110000000000
    184                                              10987654321098765432109876543210
    185                                              xxxxxxxxxxxxxxx1xxxxx000x00100x1
    186                                              stlxr.  */
    187                                           return 923;
    188                                         }
    189                                     }
    190                                   else
    191                                     {
    192                                       if (((word >> 31) & 0x1) == 0)
    193                                         {
    194                                           /* 33222222222211111111110000000000
    195                                              10987654321098765432109876543210
    196                                              xxxxxxxxxxxxxxx1xxxxx100x00100x0
    197                                              caspl.  */
    198                                           return 992;
    199                                         }
    200                                       else
    201                                         {
    202                                           /* 33222222222211111111110000000000
    203                                              10987654321098765432109876543210
    204                                              xxxxxxxxxxxxxxx1xxxxx100x00100x1
    205                                              stlxp.  */
    206                                           return 925;
    207                                         }
    208                                     }
    209                                 }
    210                             }
    211                           else
    212                             {
    213                               /* 33222222222211111111110000000000
    214                                  10987654321098765432109876543210
    215                                  xxxxxxxxxxxxxxxxxxxxxx00x00101xx
    216                                  stnp.  */
    217                               return 941;
    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 939;
    235                                         }
    236                                       else
    237                                         {
    238                                           /* 33222222222211111111110000000000
    239                                              10987654321098765432109876543210
    240                                              xxxxxxxxxxxxxxx0xxxxx001x00100x1
    241                                              stllr.  */
    242                                           return 938;
    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 978;
    256                                             }
    257                                           else
    258                                             {
    259                                               /* 33222222222211111111110000000000
    260                                                  10987654321098765432109876543210
    261                                                  xxxxxxxxxxxxxxx0xxxxx101x0010010
    262                                                  cash.  */
    263                                               return 979;
    264                                             }
    265                                         }
    266                                       else
    267                                         {
    268                                           /* 33222222222211111111110000000000
    269                                              10987654321098765432109876543210
    270                                              xxxxxxxxxxxxxxx0xxxxx101x00100x1
    271                                              cas.  */
    272                                           return 980;
    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 914;
    289                                             }
    290                                           else
    291                                             {
    292                                               /* 33222222222211111111110000000000
    293                                                  10987654321098765432109876543210
    294                                                  xxxxxxxxxxxxxxx1xxxxx001x0010010
    295                                                  stlrh.  */
    296                                               return 920;
    297                                             }
    298                                         }
    299                                       else
    300                                         {
    301                                           /* 33222222222211111111110000000000
    302                                              10987654321098765432109876543210
    303                                              xxxxxxxxxxxxxxx1xxxxx001x00100x1
    304                                              stlr.  */
    305                                           return 930;
    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 982;
    319                                             }
    320                                           else
    321                                             {
    322                                               /* 33222222222211111111110000000000
    323                                                  10987654321098765432109876543210
    324                                                  xxxxxxxxxxxxxxx1xxxxx101x0010010
    325                                                  caslh.  */
    326                                               return 985;
    327                                             }
    328                                         }
    329                                       else
    330                                         {
    331                                           /* 33222222222211111111110000000000
    332                                              10987654321098765432109876543210
    333                                              xxxxxxxxxxxxxxx1xxxxx101x00100x1
    334                                              casl.  */
    335                                           return 988;
    336                                         }
    337                                     }
    338                                 }
    339                             }
    340                           else
    341                             {
    342                               /* 33222222222211111111110000000000
    343                                  10987654321098765432109876543210
    344                                  xxxxxxxxxxxxxxxxxxxxxx01x00101xx
    345                                  stp.  */
    346                               return 950;
    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 912;
    369                                             }
    370                                           else
    371                                             {
    372                                               /* 33222222222211111111110000000000
    373                                                  10987654321098765432109876543210
    374                                                  xxxxxxxxxxxxxxx0xxxxx010x0010010
    375                                                  ldxrh.  */
    376                                               return 918;
    377                                             }
    378                                         }
    379                                       else
    380                                         {
    381                                           /* 33222222222211111111110000000000
    382                                              10987654321098765432109876543210
    383                                              xxxxxxxxxxxxxxx0xxxxx010x00100x1
    384                                              ldxr.  */
    385                                           return 926;
    386                                         }
    387                                     }
    388                                   else
    389                                     {
    390                                       if (((word >> 31) & 0x1) == 0)
    391                                         {
    392                                           /* 33222222222211111111110000000000
    393                                              10987654321098765432109876543210
    394                                              xxxxxxxxxxxxxxx0xxxxx110x00100x0
    395                                              caspa.  */
    396                                           return 991;
    397                                         }
    398                                       else
    399                                         {
    400                                           /* 33222222222211111111110000000000
    401                                              10987654321098765432109876543210
    402                                              xxxxxxxxxxxxxxx0xxxxx110x00100x1
    403                                              ldxp.  */
    404                                           return 928;
    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 913;
    421                                             }
    422                                           else
    423                                             {
    424                                               /* 33222222222211111111110000000000
    425                                                  10987654321098765432109876543210
    426                                                  xxxxxxxxxxxxxxx1xxxxx010x0010010
    427                                                  ldaxrh.  */
    428                                               return 919;
    429                                             }
    430                                         }
    431                                       else
    432                                         {
    433                                           /* 33222222222211111111110000000000
    434                                              10987654321098765432109876543210
    435                                              xxxxxxxxxxxxxxx1xxxxx010x00100x1
    436                                              ldaxr.  */
    437                                           return 927;
    438                                         }
    439                                     }
    440                                   else
    441                                     {
    442                                       if (((word >> 31) & 0x1) == 0)
    443                                         {
    444                                           /* 33222222222211111111110000000000
    445                                              10987654321098765432109876543210
    446                                              xxxxxxxxxxxxxxx1xxxxx110x00100x0
    447                                              caspal.  */
    448                                           return 993;
    449                                         }
    450                                       else
    451                                         {
    452                                           /* 33222222222211111111110000000000
    453                                              10987654321098765432109876543210
    454                                              xxxxxxxxxxxxxxx1xxxxx110x00100x1
    455                                              ldaxp.  */
    456                                           return 929;
    457                                         }
    458                                     }
    459                                 }
    460                             }
    461                           else
    462                             {
    463                               if (((word >> 30) & 0x1) == 0)
    464                                 {
    465                                   /* 33222222222211111111110000000000
    466                                      10987654321098765432109876543210
    467                                      xxxxxxxxxxxxxxxxxxxxxx10x001010x
    468                                      ldnp.  */
    469                                   return 942;
    470                                 }
    471                               else
    472                                 {
    473                                   /* 33222222222211111111110000000000
    474                                      10987654321098765432109876543210
    475                                      xxxxxxxxxxxxxxxxxxxxxx10x001011x
    476                                      ldpsw.  */
    477                                   return 949;
    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 936;
    498                                             }
    499                                           else
    500                                             {
    501                                               /* 33222222222211111111110000000000
    502                                                  10987654321098765432109876543210
    503                                                  xxxxxxxxxxxxxxx0xxxxx011x0010010
    504                                                  ldlarh.  */
    505                                               return 937;
    506                                             }
    507                                         }
    508                                       else
    509                                         {
    510                                           /* 33222222222211111111110000000000
    511                                              10987654321098765432109876543210
    512                                              xxxxxxxxxxxxxxx0xxxxx011x00100x1
    513                                              ldlar.  */
    514                                           return 935;
    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 981;
    528                                             }
    529                                           else
    530                                             {
    531                                               /* 33222222222211111111110000000000
    532                                                  10987654321098765432109876543210
    533                                                  xxxxxxxxxxxxxxx0xxxxx111x0010010
    534                                                  casah.  */
    535                                               return 984;
    536                                             }
    537                                         }
    538                                       else
    539                                         {
    540                                           /* 33222222222211111111110000000000
    541                                              10987654321098765432109876543210
    542                                              xxxxxxxxxxxxxxx0xxxxx111x00100x1
    543                                              casa.  */
    544                                           return 987;
    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 915;
    561                                             }
    562                                           else
    563                                             {
    564                                               /* 33222222222211111111110000000000
    565                                                  10987654321098765432109876543210
    566                                                  xxxxxxxxxxxxxxx1xxxxx011x0010010
    567                                                  ldarh.  */
    568                                               return 921;
    569                                             }
    570                                         }
    571                                       else
    572                                         {
    573                                           /* 33222222222211111111110000000000
    574                                              10987654321098765432109876543210
    575                                              xxxxxxxxxxxxxxx1xxxxx011x00100x1
    576                                              ldar.  */
    577                                           return 931;
    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 983;
    591                                             }
    592                                           else
    593                                             {
    594                                               /* 33222222222211111111110000000000
    595                                                  10987654321098765432109876543210
    596                                                  xxxxxxxxxxxxxxx1xxxxx111x0010010
    597                                                  casalh.  */
    598                                               return 986;
    599                                             }
    600                                         }
    601                                       else
    602                                         {
    603                                           /* 33222222222211111111110000000000
    604                                              10987654321098765432109876543210
    605                                              xxxxxxxxxxxxxxx1xxxxx111x00100x1
    606                                              casal.  */
    607                                           return 989;
    608                                         }
    609                                     }
    610                                 }
    611                             }
    612                           else
    613                             {
    614                               if (((word >> 30) & 0x1) == 0)
    615                                 {
    616                                   /* 33222222222211111111110000000000
    617                                      10987654321098765432109876543210
    618                                      xxxxxxxxxxxxxxxxxxxxxx11x001010x
    619                                      ldp.  */
    620                                   return 951;
    621                                 }
    622                               else
    623                                 {
    624                                   /* 33222222222211111111110000000000
    625                                      10987654321098765432109876543210
    626                                      xxxxxxxxxxxxxxxxxxxxxx11x001011x
    627                                      ldpsw.  */
    628                                   return 954;
    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 955;
    647                             }
    648                           else
    649                             {
    650                               if (((word >> 30) & 0x1) == 0)
    651                                 {
    652                                   /* 33222222222211111111110000000000
    653                                      10987654321098765432109876543210
    654                                      xxxxxxxxxxxxxxxxxxxxxxxx00011001
    655                                      ldrsw.  */
    656                                   return 957;
    657                                 }
    658                               else
    659                                 {
    660                                   /* 33222222222211111111110000000000
    661                                      10987654321098765432109876543210
    662                                      xxxxxxxxxxxxxxxxxxxxxxxx00011011
    663                                      prfm.  */
    664                                   return 958;
    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 896;
    689                                                     }
    690                                                   else
    691                                                     {
    692                                                       /* 33222222222211111111110000000000
    693                                                          10987654321098765432109876543210
    694                                                          xxxxxxxxxx00xxxxxxxxx00000011110
    695                                                          sturh.  */
    696                                                       return 901;
    697                                                     }
    698                                                 }
    699                                               else
    700                                                 {
    701                                                   /* 33222222222211111111110000000000
    702                                                      10987654321098765432109876543210
    703                                                      xxxxxxxxxx00xxxxxxxxx000000111x1
    704                                                      stur.  */
    705                                                   return 904;
    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 897;
    719                                                     }
    720                                                   else
    721                                                     {
    722                                                       /* 33222222222211111111110000000000
    723                                                          10987654321098765432109876543210
    724                                                          xxxxxxxxxx00xxxxxxxxx01000011110
    725                                                          ldurh.  */
    726                                                       return 902;
    727                                                     }
    728                                                 }
    729                                               else
    730                                                 {
    731                                                   /* 33222222222211111111110000000000
    732                                                      10987654321098765432109876543210
    733                                                      xxxxxxxxxx00xxxxxxxxx010000111x1
    734                                                      ldur.  */
    735                                                   return 905;
    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 898;
    750                                                 }
    751                                               else
    752                                                 {
    753                                                   /* 33222222222211111111110000000000
    754                                                      10987654321098765432109876543210
    755                                                      xxxxxxxxxx00xxxxxxxxx0x100011101
    756                                                      ldursw.  */
    757                                                   return 906;
    758                                                 }
    759                                             }
    760                                           else
    761                                             {
    762                                               if (((word >> 31) & 0x1) == 0)
    763                                                 {
    764                                                   /* 33222222222211111111110000000000
    765                                                      10987654321098765432109876543210
    766                                                      xxxxxxxxxx00xxxxxxxxx0x100011110
    767                                                      ldursh.  */
    768                                                   return 903;
    769                                                 }
    770                                               else
    771                                                 {
    772                                                   /* 33222222222211111111110000000000
    773                                                      10987654321098765432109876543210
    774                                                      xxxxxxxxxx00xxxxxxxxx0x100011111
    775                                                      prfum.  */
    776                                                   return 907;
    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 1006;
    804                                                                     }
    805                                                                   else
    806                                                                     {
    807                                                                       /* 33222222222211111111110000000000
    808                                                                          10987654321098765432109876543210
    809                                                                          xxxxxxxxxx000000xxxxx10000011110
    810                                                                          ldaddh.  */
    811                                                                       return 1007;
    812                                                                     }
    813                                                                 }
    814                                                               else
    815                                                                 {
    816                                                                   /* 33222222222211111111110000000000
    817                                                                      10987654321098765432109876543210
    818                                                                      xxxxxxxxxx000000xxxxx100000111x1
    819                                                                      ldadd.  */
    820                                                                   return 1008;
    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 1009;
    834                                                                     }
    835                                                                   else
    836                                                                     {
    837                                                                       /* 33222222222211111111110000000000
    838                                                                          10987654321098765432109876543210
    839                                                                          xxxxxxxxxx000000xxxxx10100011110
    840                                                                          ldaddah.  */
    841                                                                       return 1012;
    842                                                                     }
    843                                                                 }
    844                                                               else
    845                                                                 {
    846                                                                   /* 33222222222211111111110000000000
    847                                                                      10987654321098765432109876543210
    848                                                                      xxxxxxxxxx000000xxxxx101000111x1
    849                                                                      ldadda.  */
    850                                                                   return 1015;
    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 1010;
    867                                                                     }
    868                                                                   else
    869                                                                     {
    870                                                                       /* 33222222222211111111110000000000
    871                                                                          10987654321098765432109876543210
    872                                                                          xxxxxxxxxx000000xxxxx11000011110
    873                                                                          ldaddlh.  */
    874                                                                       return 1013;
    875                                                                     }
    876                                                                 }
    877                                                               else
    878                                                                 {
    879                                                                   /* 33222222222211111111110000000000
    880                                                                      10987654321098765432109876543210
    881                                                                      xxxxxxxxxx000000xxxxx110000111x1
    882                                                                      ldaddl.  */
    883                                                                   return 1016;
    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 1011;
    897                                                                     }
    898                                                                   else
    899                                                                     {
    900                                                                       /* 33222222222211111111110000000000
    901                                                                          10987654321098765432109876543210
    902                                                                          xxxxxxxxxx000000xxxxx11100011110
    903                                                                          ldaddalh.  */
    904                                                                       return 1014;
    905                                                                     }
    906                                                                 }
    907                                                               else
    908                                                                 {
    909                                                                   /* 33222222222211111111110000000000
    910                                                                      10987654321098765432109876543210
    911                                                                      xxxxxxxxxx000000xxxxx111000111x1
    912                                                                      ldaddal.  */
    913                                                                   return 1017;
    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 994;
    933                                                                     }
    934                                                                   else
    935                                                                     {
    936                                                                       /* 33222222222211111111110000000000
    937                                                                          10987654321098765432109876543210
    938                                                                          xxxxxxxxxx000001xxxxx10000011110
    939                                                                          swph.  */
    940                                                                       return 995;
    941                                                                     }
    942                                                                 }
    943                                                               else
    944                                                                 {
    945                                                                   /* 33222222222211111111110000000000
    946                                                                      10987654321098765432109876543210
    947                                                                      xxxxxxxxxx000001xxxxx100000111x1
    948                                                                      swp.  */
    949                                                                   return 996;
    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 997;
    963                                                                     }
    964                                                                   else
    965                                                                     {
    966                                                                       /* 33222222222211111111110000000000
    967                                                                          10987654321098765432109876543210
    968                                                                          xxxxxxxxxx000001xxxxx10100011110
    969                                                                          swpah.  */
    970                                                                       return 1000;
    971                                                                     }
    972                                                                 }
    973                                                               else
    974                                                                 {
    975                                                                   /* 33222222222211111111110000000000
    976                                                                      10987654321098765432109876543210
    977                                                                      xxxxxxxxxx000001xxxxx101000111x1
    978                                                                      swpa.  */
    979                                                                   return 1003;
    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 998;
    996                                                                     }
    997                                                                   else
    998                                                                     {
    999                                                                       /* 33222222222211111111110000000000
   1000                                                                          10987654321098765432109876543210
   1001                                                                          xxxxxxxxxx000001xxxxx11000011110
   1002                                                                          swplh.  */
   1003                                                                       return 1001;
   1004                                                                     }
   1005                                                                 }
   1006                                                               else
   1007                                                                 {
   1008                                                                   /* 33222222222211111111110000000000
   1009                                                                      10987654321098765432109876543210
   1010                                                                      xxxxxxxxxx000001xxxxx110000111x1
   1011                                                                      swpl.  */
   1012                                                                   return 1004;
   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 999;
   1026                                                                     }
   1027                                                                   else
   1028                                                                     {
   1029                                                                       /* 33222222222211111111110000000000
   1030                                                                          10987654321098765432109876543210
   1031                                                                          xxxxxxxxxx000001xxxxx11100011110
   1032                                                                          swpalh.  */
   1033                                                                       return 1002;
   1034                                                                     }
   1035                                                                 }
   1036                                                               else
   1037                                                                 {
   1038                                                                   /* 33222222222211111111110000000000
   1039                                                                      10987654321098765432109876543210
   1040                                                                      xxxxxxxxxx000001xxxxx111000111x1
   1041                                                                      swpal.  */
   1042                                                                   return 1005;
   1043                                                                 }
   1044                                                             }
   1045                                                         }
   1046                                                     }
   1047                                                 }
   1048                                               else
   1049                                                 {
   1050                                                   if (((word >> 15) & 0x1) == 0)
   1051                                                     {
   1052                                                       if (((word >> 22) & 0x1) == 0)
   1053                                                         {
   1054                                                           if (((word >> 23) & 0x1) == 0)
   1055                                                             {
   1056                                                               if (((word >> 31) & 0x1) == 0)
   1057                                                                 {
   1058                                                                   if (((word >> 30) & 0x1) == 0)
   1059                                                                     {
   1060                                                                       /* 33222222222211111111110000000000
   1061                                                                          10987654321098765432109876543210
   1062                                                                          xxxxxxxxxx000010xxxxx10000011100
   1063                                                                          ldsmaxb.  */
   1064                                                                       return 1054;
   1065                                                                     }
   1066                                                                   else
   1067                                                                     {
   1068                                                                       /* 33222222222211111111110000000000
   1069                                                                          10987654321098765432109876543210
   1070                                                                          xxxxxxxxxx000010xxxxx10000011110
   1071                                                                          ldsmaxh.  */
   1072                                                                       return 1055;
   1073                                                                     }
   1074                                                                 }
   1075                                                               else
   1076                                                                 {
   1077                                                                   /* 33222222222211111111110000000000
   1078                                                                      10987654321098765432109876543210
   1079                                                                      xxxxxxxxxx000010xxxxx100000111x1
   1080                                                                      ldsmax.  */
   1081                                                                   return 1056;
   1082                                                                 }
   1083                                                             }
   1084                                                           else
   1085                                                             {
   1086                                                               if (((word >> 31) & 0x1) == 0)
   1087                                                                 {
   1088                                                                   if (((word >> 30) & 0x1) == 0)
   1089                                                                     {
   1090                                                                       /* 33222222222211111111110000000000
   1091                                                                          10987654321098765432109876543210
   1092                                                                          xxxxxxxxxx000010xxxxx10100011100
   1093                                                                          ldsmaxab.  */
   1094                                                                       return 1057;
   1095                                                                     }
   1096                                                                   else
   1097                                                                     {
   1098                                                                       /* 33222222222211111111110000000000
   1099                                                                          10987654321098765432109876543210
   1100                                                                          xxxxxxxxxx000010xxxxx10100011110
   1101                                                                          ldsmaxah.  */
   1102                                                                       return 1060;
   1103                                                                     }
   1104                                                                 }
   1105                                                               else
   1106                                                                 {
   1107                                                                   /* 33222222222211111111110000000000
   1108                                                                      10987654321098765432109876543210
   1109                                                                      xxxxxxxxxx000010xxxxx101000111x1
   1110                                                                      ldsmaxa.  */
   1111                                                                   return 1063;
   1112                                                                 }
   1113                                                             }
   1114                                                         }
   1115                                                       else
   1116                                                         {
   1117                                                           if (((word >> 23) & 0x1) == 0)
   1118                                                             {
   1119                                                               if (((word >> 31) & 0x1) == 0)
   1120                                                                 {
   1121                                                                   if (((word >> 30) & 0x1) == 0)
   1122                                                                     {
   1123                                                                       /* 33222222222211111111110000000000
   1124                                                                          10987654321098765432109876543210
   1125                                                                          xxxxxxxxxx000010xxxxx11000011100
   1126                                                                          ldsmaxlb.  */
   1127                                                                       return 1058;
   1128                                                                     }
   1129                                                                   else
   1130                                                                     {
   1131                                                                       /* 33222222222211111111110000000000
   1132                                                                          10987654321098765432109876543210
   1133                                                                          xxxxxxxxxx000010xxxxx11000011110
   1134                                                                          ldsmaxlh.  */
   1135                                                                       return 1061;
   1136                                                                     }
   1137                                                                 }
   1138                                                               else
   1139                                                                 {
   1140                                                                   /* 33222222222211111111110000000000
   1141                                                                      10987654321098765432109876543210
   1142                                                                      xxxxxxxxxx000010xxxxx110000111x1
   1143                                                                      ldsmaxl.  */
   1144                                                                   return 1064;
   1145                                                                 }
   1146                                                             }
   1147                                                           else
   1148                                                             {
   1149                                                               if (((word >> 31) & 0x1) == 0)
   1150                                                                 {
   1151                                                                   if (((word >> 30) & 0x1) == 0)
   1152                                                                     {
   1153                                                                       /* 33222222222211111111110000000000
   1154                                                                          10987654321098765432109876543210
   1155                                                                          xxxxxxxxxx000010xxxxx11100011100
   1156                                                                          ldsmaxalb.  */
   1157                                                                       return 1059;
   1158                                                                     }
   1159                                                                   else
   1160                                                                     {
   1161                                                                       /* 33222222222211111111110000000000
   1162                                                                          10987654321098765432109876543210
   1163                                                                          xxxxxxxxxx000010xxxxx11100011110
   1164                                                                          ldsmaxalh.  */
   1165                                                                       return 1062;
   1166                                                                     }
   1167                                                                 }
   1168                                                               else
   1169                                                                 {
   1170                                                                   /* 33222222222211111111110000000000
   1171                                                                      10987654321098765432109876543210
   1172                                                                      xxxxxxxxxx000010xxxxx111000111x1
   1173                                                                      ldsmaxal.  */
   1174                                                                   return 1065;
   1175                                                                 }
   1176                                                             }
   1177                                                         }
   1178                                                     }
   1179                                                   else
   1180                                                     {
   1181                                                       if (((word >> 31) & 0x1) == 0)
   1182                                                         {
   1183                                                           if (((word >> 30) & 0x1) == 0)
   1184                                                             {
   1185                                                               /* 33222222222211111111110000000000
   1186                                                                  10987654321098765432109876543210
   1187                                                                  xxxxxxxxxx000011xxxxx1xx00011100
   1188                                                                  ldaprb.  */
   1189                                                               return 932;
   1190                                                             }
   1191                                                           else
   1192                                                             {
   1193                                                               /* 33222222222211111111110000000000
   1194                                                                  10987654321098765432109876543210
   1195                                                                  xxxxxxxxxx000011xxxxx1xx00011110
   1196                                                                  ldaprh.  */
   1197                                                               return 933;
   1198                                                             }
   1199                                                         }
   1200                                                       else
   1201                                                         {
   1202                                                           /* 33222222222211111111110000000000
   1203                                                              10987654321098765432109876543210
   1204                                                              xxxxxxxxxx000011xxxxx1xx000111x1
   1205                                                              ldapr.  */
   1206                                                           return 934;
   1207                                                         }
   1208                                                     }
   1209                                                 }
   1210                                             }
   1211                                           else
   1212                                             {
   1213                                               if (((word >> 14) & 0x1) == 0)
   1214                                                 {
   1215                                                   if (((word >> 22) & 0x1) == 0)
   1216                                                     {
   1217                                                       if (((word >> 23) & 0x1) == 0)
   1218                                                         {
   1219                                                           if (((word >> 31) & 0x1) == 0)
   1220                                                             {
   1221                                                               if (((word >> 30) & 0x1) == 0)
   1222                                                                 {
   1223                                                                   /* 33222222222211111111110000000000
   1224                                                                      10987654321098765432109876543210
   1225                                                                      xxxxxxxxxx00010xxxxxx10000011100
   1226                                                                      ldeorb.  */
   1227                                                                   return 1030;
   1228                                                                 }
   1229                                                               else
   1230                                                                 {
   1231                                                                   /* 33222222222211111111110000000000
   1232                                                                      10987654321098765432109876543210
   1233                                                                      xxxxxxxxxx00010xxxxxx10000011110
   1234                                                                      ldeorh.  */
   1235                                                                   return 1031;
   1236                                                                 }
   1237                                                             }
   1238                                                           else
   1239                                                             {
   1240                                                               /* 33222222222211111111110000000000
   1241                                                                  10987654321098765432109876543210
   1242                                                                  xxxxxxxxxx00010xxxxxx100000111x1
   1243                                                                  ldeor.  */
   1244                                                               return 1032;
   1245                                                             }
   1246                                                         }
   1247                                                       else
   1248                                                         {
   1249                                                           if (((word >> 31) & 0x1) == 0)
   1250                                                             {
   1251                                                               if (((word >> 30) & 0x1) == 0)
   1252                                                                 {
   1253                                                                   /* 33222222222211111111110000000000
   1254                                                                      10987654321098765432109876543210
   1255                                                                      xxxxxxxxxx00010xxxxxx10100011100
   1256                                                                      ldeorab.  */
   1257                                                                   return 1033;
   1258                                                                 }
   1259                                                               else
   1260                                                                 {
   1261                                                                   /* 33222222222211111111110000000000
   1262                                                                      10987654321098765432109876543210
   1263                                                                      xxxxxxxxxx00010xxxxxx10100011110
   1264                                                                      ldeorah.  */
   1265                                                                   return 1036;
   1266                                                                 }
   1267                                                             }
   1268                                                           else
   1269                                                             {
   1270                                                               /* 33222222222211111111110000000000
   1271                                                                  10987654321098765432109876543210
   1272                                                                  xxxxxxxxxx00010xxxxxx101000111x1
   1273                                                                  ldeora.  */
   1274                                                               return 1039;
   1275                                                             }
   1276                                                         }
   1277                                                     }
   1278                                                   else
   1279                                                     {
   1280                                                       if (((word >> 23) & 0x1) == 0)
   1281                                                         {
   1282                                                           if (((word >> 31) & 0x1) == 0)
   1283                                                             {
   1284                                                               if (((word >> 30) & 0x1) == 0)
   1285                                                                 {
   1286                                                                   /* 33222222222211111111110000000000
   1287                                                                      10987654321098765432109876543210
   1288                                                                      xxxxxxxxxx00010xxxxxx11000011100
   1289                                                                      ldeorlb.  */
   1290                                                                   return 1034;
   1291                                                                 }
   1292                                                               else
   1293                                                                 {
   1294                                                                   /* 33222222222211111111110000000000
   1295                                                                      10987654321098765432109876543210
   1296                                                                      xxxxxxxxxx00010xxxxxx11000011110
   1297                                                                      ldeorlh.  */
   1298                                                                   return 1037;
   1299                                                                 }
   1300                                                             }
   1301                                                           else
   1302                                                             {
   1303                                                               /* 33222222222211111111110000000000
   1304                                                                  10987654321098765432109876543210
   1305                                                                  xxxxxxxxxx00010xxxxxx110000111x1
   1306                                                                  ldeorl.  */
   1307                                                               return 1040;
   1308                                                             }
   1309                                                         }
   1310                                                       else
   1311                                                         {
   1312                                                           if (((word >> 31) & 0x1) == 0)
   1313                                                             {
   1314                                                               if (((word >> 30) & 0x1) == 0)
   1315                                                                 {
   1316                                                                   /* 33222222222211111111110000000000
   1317                                                                      10987654321098765432109876543210
   1318                                                                      xxxxxxxxxx00010xxxxxx11100011100
   1319                                                                      ldeoralb.  */
   1320                                                                   return 1035;
   1321                                                                 }
   1322                                                               else
   1323                                                                 {
   1324                                                                   /* 33222222222211111111110000000000
   1325                                                                      10987654321098765432109876543210
   1326                                                                      xxxxxxxxxx00010xxxxxx11100011110
   1327                                                                      ldeoralh.  */
   1328                                                                   return 1038;
   1329                                                                 }
   1330                                                             }
   1331                                                           else
   1332                                                             {
   1333                                                               /* 33222222222211111111110000000000
   1334                                                                  10987654321098765432109876543210
   1335                                                                  xxxxxxxxxx00010xxxxxx111000111x1
   1336                                                                  ldeoral.  */
   1337                                                               return 1041;
   1338                                                             }
   1339                                                         }
   1340                                                     }
   1341                                                 }
   1342                                               else
   1343                                                 {
   1344                                                   if (((word >> 22) & 0x1) == 0)
   1345                                                     {
   1346                                                       if (((word >> 23) & 0x1) == 0)
   1347                                                         {
   1348                                                           if (((word >> 31) & 0x1) == 0)
   1349                                                             {
   1350                                                               if (((word >> 30) & 0x1) == 0)
   1351                                                                 {
   1352                                                                   /* 33222222222211111111110000000000
   1353                                                                      10987654321098765432109876543210
   1354                                                                      xxxxxxxxxx00011xxxxxx10000011100
   1355                                                                      ldumaxb.  */
   1356                                                                   return 1078;
   1357                                                                 }
   1358                                                               else
   1359                                                                 {
   1360                                                                   /* 33222222222211111111110000000000
   1361                                                                      10987654321098765432109876543210
   1362                                                                      xxxxxxxxxx00011xxxxxx10000011110
   1363                                                                      ldumaxh.  */
   1364                                                                   return 1079;
   1365                                                                 }
   1366                                                             }
   1367                                                           else
   1368                                                             {
   1369                                                               /* 33222222222211111111110000000000
   1370                                                                  10987654321098765432109876543210
   1371                                                                  xxxxxxxxxx00011xxxxxx100000111x1
   1372                                                                  ldumax.  */
   1373                                                               return 1080;
   1374                                                             }
   1375                                                         }
   1376                                                       else
   1377                                                         {
   1378                                                           if (((word >> 31) & 0x1) == 0)
   1379                                                             {
   1380                                                               if (((word >> 30) & 0x1) == 0)
   1381                                                                 {
   1382                                                                   /* 33222222222211111111110000000000
   1383                                                                      10987654321098765432109876543210
   1384                                                                      xxxxxxxxxx00011xxxxxx10100011100
   1385                                                                      ldumaxab.  */
   1386                                                                   return 1081;
   1387                                                                 }
   1388                                                               else
   1389                                                                 {
   1390                                                                   /* 33222222222211111111110000000000
   1391                                                                      10987654321098765432109876543210
   1392                                                                      xxxxxxxxxx00011xxxxxx10100011110
   1393                                                                      ldumaxah.  */
   1394                                                                   return 1084;
   1395                                                                 }
   1396                                                             }
   1397                                                           else
   1398                                                             {
   1399                                                               /* 33222222222211111111110000000000
   1400                                                                  10987654321098765432109876543210
   1401                                                                  xxxxxxxxxx00011xxxxxx101000111x1
   1402                                                                  ldumaxa.  */
   1403                                                               return 1087;
   1404                                                             }
   1405                                                         }
   1406                                                     }
   1407                                                   else
   1408                                                     {
   1409                                                       if (((word >> 23) & 0x1) == 0)
   1410                                                         {
   1411                                                           if (((word >> 31) & 0x1) == 0)
   1412                                                             {
   1413                                                               if (((word >> 30) & 0x1) == 0)
   1414                                                                 {
   1415                                                                   /* 33222222222211111111110000000000
   1416                                                                      10987654321098765432109876543210
   1417                                                                      xxxxxxxxxx00011xxxxxx11000011100
   1418                                                                      ldumaxlb.  */
   1419                                                                   return 1082;
   1420                                                                 }
   1421                                                               else
   1422                                                                 {
   1423                                                                   /* 33222222222211111111110000000000
   1424                                                                      10987654321098765432109876543210
   1425                                                                      xxxxxxxxxx00011xxxxxx11000011110
   1426                                                                      ldumaxlh.  */
   1427                                                                   return 1085;
   1428                                                                 }
   1429                                                             }
   1430                                                           else
   1431                                                             {
   1432                                                               /* 33222222222211111111110000000000
   1433                                                                  10987654321098765432109876543210
   1434                                                                  xxxxxxxxxx00011xxxxxx110000111x1
   1435                                                                  ldumaxl.  */
   1436                                                               return 1088;
   1437                                                             }
   1438                                                         }
   1439                                                       else
   1440                                                         {
   1441                                                           if (((word >> 31) & 0x1) == 0)
   1442                                                             {
   1443                                                               if (((word >> 30) & 0x1) == 0)
   1444                                                                 {
   1445                                                                   /* 33222222222211111111110000000000
   1446                                                                      10987654321098765432109876543210
   1447                                                                      xxxxxxxxxx00011xxxxxx11100011100
   1448                                                                      ldumaxalb.  */
   1449                                                                   return 1083;
   1450                                                                 }
   1451                                                               else
   1452                                                                 {
   1453                                                                   /* 33222222222211111111110000000000
   1454                                                                      10987654321098765432109876543210
   1455                                                                      xxxxxxxxxx00011xxxxxx11100011110
   1456                                                                      ldumaxalh.  */
   1457                                                                   return 1086;
   1458                                                                 }
   1459                                                             }
   1460                                                           else
   1461                                                             {
   1462                                                               /* 33222222222211111111110000000000
   1463                                                                  10987654321098765432109876543210
   1464                                                                  xxxxxxxxxx00011xxxxxx111000111x1
   1465                                                                  ldumaxal.  */
   1466                                                               return 1089;
   1467                                                             }
   1468                                                         }
   1469                                                     }
   1470                                                 }
   1471                                             }
   1472                                         }
   1473                                       else
   1474                                         {
   1475                                           if (((word >> 13) & 0x1) == 0)
   1476                                             {
   1477                                               if (((word >> 14) & 0x1) == 0)
   1478                                                 {
   1479                                                   if (((word >> 22) & 0x1) == 0)
   1480                                                     {
   1481                                                       if (((word >> 23) & 0x1) == 0)
   1482                                                         {
   1483                                                           if (((word >> 31) & 0x1) == 0)
   1484                                                             {
   1485                                                               if (((word >> 30) & 0x1) == 0)
   1486                                                                 {
   1487                                                                   /* 33222222222211111111110000000000
   1488                                                                      10987654321098765432109876543210
   1489                                                                      xxxxxxxxxx00100xxxxxx10000011100
   1490                                                                      ldclrb.  */
   1491                                                                   return 1018;
   1492                                                                 }
   1493                                                               else
   1494                                                                 {
   1495                                                                   /* 33222222222211111111110000000000
   1496                                                                      10987654321098765432109876543210
   1497                                                                      xxxxxxxxxx00100xxxxxx10000011110
   1498                                                                      ldclrh.  */
   1499                                                                   return 1019;
   1500                                                                 }
   1501                                                             }
   1502                                                           else
   1503                                                             {
   1504                                                               /* 33222222222211111111110000000000
   1505                                                                  10987654321098765432109876543210
   1506                                                                  xxxxxxxxxx00100xxxxxx100000111x1
   1507                                                                  ldclr.  */
   1508                                                               return 1020;
   1509                                                             }
   1510                                                         }
   1511                                                       else
   1512                                                         {
   1513                                                           if (((word >> 31) & 0x1) == 0)
   1514                                                             {
   1515                                                               if (((word >> 30) & 0x1) == 0)
   1516                                                                 {
   1517                                                                   /* 33222222222211111111110000000000
   1518                                                                      10987654321098765432109876543210
   1519                                                                      xxxxxxxxxx00100xxxxxx10100011100
   1520                                                                      ldclrab.  */
   1521                                                                   return 1021;
   1522                                                                 }
   1523                                                               else
   1524                                                                 {
   1525                                                                   /* 33222222222211111111110000000000
   1526                                                                      10987654321098765432109876543210
   1527                                                                      xxxxxxxxxx00100xxxxxx10100011110
   1528                                                                      ldclrah.  */
   1529                                                                   return 1024;
   1530                                                                 }
   1531                                                             }
   1532                                                           else
   1533                                                             {
   1534                                                               /* 33222222222211111111110000000000
   1535                                                                  10987654321098765432109876543210
   1536                                                                  xxxxxxxxxx00100xxxxxx101000111x1
   1537                                                                  ldclra.  */
   1538                                                               return 1027;
   1539                                                             }
   1540                                                         }
   1541                                                     }
   1542                                                   else
   1543                                                     {
   1544                                                       if (((word >> 23) & 0x1) == 0)
   1545                                                         {
   1546                                                           if (((word >> 31) & 0x1) == 0)
   1547                                                             {
   1548                                                               if (((word >> 30) & 0x1) == 0)
   1549                                                                 {
   1550                                                                   /* 33222222222211111111110000000000
   1551                                                                      10987654321098765432109876543210
   1552                                                                      xxxxxxxxxx00100xxxxxx11000011100
   1553                                                                      ldclrlb.  */
   1554                                                                   return 1022;
   1555                                                                 }
   1556                                                               else
   1557                                                                 {
   1558                                                                   /* 33222222222211111111110000000000
   1559                                                                      10987654321098765432109876543210
   1560                                                                      xxxxxxxxxx00100xxxxxx11000011110
   1561                                                                      ldclrlh.  */
   1562                                                                   return 1025;
   1563                                                                 }
   1564                                                             }
   1565                                                           else
   1566                                                             {
   1567                                                               /* 33222222222211111111110000000000
   1568                                                                  10987654321098765432109876543210
   1569                                                                  xxxxxxxxxx00100xxxxxx110000111x1
   1570                                                                  ldclrl.  */
   1571                                                               return 1028;
   1572                                                             }
   1573                                                         }
   1574                                                       else
   1575                                                         {
   1576                                                           if (((word >> 31) & 0x1) == 0)
   1577                                                             {
   1578                                                               if (((word >> 30) & 0x1) == 0)
   1579                                                                 {
   1580                                                                   /* 33222222222211111111110000000000
   1581                                                                      10987654321098765432109876543210
   1582                                                                      xxxxxxxxxx00100xxxxxx11100011100
   1583                                                                      ldclralb.  */
   1584                                                                   return 1023;
   1585                                                                 }
   1586                                                               else
   1587                                                                 {
   1588                                                                   /* 33222222222211111111110000000000
   1589                                                                      10987654321098765432109876543210
   1590                                                                      xxxxxxxxxx00100xxxxxx11100011110
   1591                                                                      ldclralh.  */
   1592                                                                   return 1026;
   1593                                                                 }
   1594                                                             }
   1595                                                           else
   1596                                                             {
   1597                                                               /* 33222222222211111111110000000000
   1598                                                                  10987654321098765432109876543210
   1599                                                                  xxxxxxxxxx00100xxxxxx111000111x1
   1600                                                                  ldclral.  */
   1601                                                               return 1029;
   1602                                                             }
   1603                                                         }
   1604                                                     }
   1605                                                 }
   1606                                               else
   1607                                                 {
   1608                                                   if (((word >> 22) & 0x1) == 0)
   1609                                                     {
   1610                                                       if (((word >> 23) & 0x1) == 0)
   1611                                                         {
   1612                                                           if (((word >> 31) & 0x1) == 0)
   1613                                                             {
   1614                                                               if (((word >> 30) & 0x1) == 0)
   1615                                                                 {
   1616                                                                   /* 33222222222211111111110000000000
   1617                                                                      10987654321098765432109876543210
   1618                                                                      xxxxxxxxxx00101xxxxxx10000011100
   1619                                                                      ldsminb.  */
   1620                                                                   return 1066;
   1621                                                                 }
   1622                                                               else
   1623                                                                 {
   1624                                                                   /* 33222222222211111111110000000000
   1625                                                                      10987654321098765432109876543210
   1626                                                                      xxxxxxxxxx00101xxxxxx10000011110
   1627                                                                      ldsminh.  */
   1628                                                                   return 1067;
   1629                                                                 }
   1630                                                             }
   1631                                                           else
   1632                                                             {
   1633                                                               /* 33222222222211111111110000000000
   1634                                                                  10987654321098765432109876543210
   1635                                                                  xxxxxxxxxx00101xxxxxx100000111x1
   1636                                                                  ldsmin.  */
   1637                                                               return 1068;
   1638                                                             }
   1639                                                         }
   1640                                                       else
   1641                                                         {
   1642                                                           if (((word >> 31) & 0x1) == 0)
   1643                                                             {
   1644                                                               if (((word >> 30) & 0x1) == 0)
   1645                                                                 {
   1646                                                                   /* 33222222222211111111110000000000
   1647                                                                      10987654321098765432109876543210
   1648                                                                      xxxxxxxxxx00101xxxxxx10100011100
   1649                                                                      ldsminab.  */
   1650                                                                   return 1069;
   1651                                                                 }
   1652                                                               else
   1653                                                                 {
   1654                                                                   /* 33222222222211111111110000000000
   1655                                                                      10987654321098765432109876543210
   1656                                                                      xxxxxxxxxx00101xxxxxx10100011110
   1657                                                                      ldsminah.  */
   1658                                                                   return 1072;
   1659                                                                 }
   1660                                                             }
   1661                                                           else
   1662                                                             {
   1663                                                               /* 33222222222211111111110000000000
   1664                                                                  10987654321098765432109876543210
   1665                                                                  xxxxxxxxxx00101xxxxxx101000111x1
   1666                                                                  ldsmina.  */
   1667                                                               return 1075;
   1668                                                             }
   1669                                                         }
   1670                                                     }
   1671                                                   else
   1672                                                     {
   1673                                                       if (((word >> 23) & 0x1) == 0)
   1674                                                         {
   1675                                                           if (((word >> 31) & 0x1) == 0)
   1676                                                             {
   1677                                                               if (((word >> 30) & 0x1) == 0)
   1678                                                                 {
   1679                                                                   /* 33222222222211111111110000000000
   1680                                                                      10987654321098765432109876543210
   1681                                                                      xxxxxxxxxx00101xxxxxx11000011100
   1682                                                                      ldsminlb.  */
   1683                                                                   return 1070;
   1684                                                                 }
   1685                                                               else
   1686                                                                 {
   1687                                                                   /* 33222222222211111111110000000000
   1688                                                                      10987654321098765432109876543210
   1689                                                                      xxxxxxxxxx00101xxxxxx11000011110
   1690                                                                      ldsminlh.  */
   1691                                                                   return 1073;
   1692                                                                 }
   1693                                                             }
   1694                                                           else
   1695                                                             {
   1696                                                               /* 33222222222211111111110000000000
   1697                                                                  10987654321098765432109876543210
   1698                                                                  xxxxxxxxxx00101xxxxxx110000111x1
   1699                                                                  ldsminl.  */
   1700                                                               return 1076;
   1701                                                             }
   1702                                                         }
   1703                                                       else
   1704                                                         {
   1705                                                           if (((word >> 31) & 0x1) == 0)
   1706                                                             {
   1707                                                               if (((word >> 30) & 0x1) == 0)
   1708                                                                 {
   1709                                                                   /* 33222222222211111111110000000000
   1710                                                                      10987654321098765432109876543210
   1711                                                                      xxxxxxxxxx00101xxxxxx11100011100
   1712                                                                      ldsminalb.  */
   1713                                                                   return 1071;
   1714                                                                 }
   1715                                                               else
   1716                                                                 {
   1717                                                                   /* 33222222222211111111110000000000
   1718                                                                      10987654321098765432109876543210
   1719                                                                      xxxxxxxxxx00101xxxxxx11100011110
   1720                                                                      ldsminalh.  */
   1721                                                                   return 1074;
   1722                                                                 }
   1723                                                             }
   1724                                                           else
   1725                                                             {
   1726                                                               /* 33222222222211111111110000000000
   1727                                                                  10987654321098765432109876543210
   1728                                                                  xxxxxxxxxx00101xxxxxx111000111x1
   1729                                                                  ldsminal.  */
   1730                                                               return 1077;
   1731                                                             }
   1732                                                         }
   1733                                                     }
   1734                                                 }
   1735                                             }
   1736                                           else
   1737                                             {
   1738                                               if (((word >> 14) & 0x1) == 0)
   1739                                                 {
   1740                                                   if (((word >> 22) & 0x1) == 0)
   1741                                                     {
   1742                                                       if (((word >> 23) & 0x1) == 0)
   1743                                                         {
   1744                                                           if (((word >> 31) & 0x1) == 0)
   1745                                                             {
   1746                                                               if (((word >> 30) & 0x1) == 0)
   1747                                                                 {
   1748                                                                   /* 33222222222211111111110000000000
   1749                                                                      10987654321098765432109876543210
   1750                                                                      xxxxxxxxxx00110xxxxxx10000011100
   1751                                                                      ldsetb.  */
   1752                                                                   return 1042;
   1753                                                                 }
   1754                                                               else
   1755                                                                 {
   1756                                                                   /* 33222222222211111111110000000000
   1757                                                                      10987654321098765432109876543210
   1758                                                                      xxxxxxxxxx00110xxxxxx10000011110
   1759                                                                      ldseth.  */
   1760                                                                   return 1043;
   1761                                                                 }
   1762                                                             }
   1763                                                           else
   1764                                                             {
   1765                                                               /* 33222222222211111111110000000000
   1766                                                                  10987654321098765432109876543210
   1767                                                                  xxxxxxxxxx00110xxxxxx100000111x1
   1768                                                                  ldset.  */
   1769                                                               return 1044;
   1770                                                             }
   1771                                                         }
   1772                                                       else
   1773                                                         {
   1774                                                           if (((word >> 31) & 0x1) == 0)
   1775                                                             {
   1776                                                               if (((word >> 30) & 0x1) == 0)
   1777                                                                 {
   1778                                                                   /* 33222222222211111111110000000000
   1779                                                                      10987654321098765432109876543210
   1780                                                                      xxxxxxxxxx00110xxxxxx10100011100
   1781                                                                      ldsetab.  */
   1782                                                                   return 1045;
   1783                                                                 }
   1784                                                               else
   1785                                                                 {
   1786                                                                   /* 33222222222211111111110000000000
   1787                                                                      10987654321098765432109876543210
   1788                                                                      xxxxxxxxxx00110xxxxxx10100011110
   1789                                                                      ldsetah.  */
   1790                                                                   return 1048;
   1791                                                                 }
   1792                                                             }
   1793                                                           else
   1794                                                             {
   1795                                                               /* 33222222222211111111110000000000
   1796                                                                  10987654321098765432109876543210
   1797                                                                  xxxxxxxxxx00110xxxxxx101000111x1
   1798                                                                  ldseta.  */
   1799                                                               return 1051;
   1800                                                             }
   1801                                                         }
   1802                                                     }
   1803                                                   else
   1804                                                     {
   1805                                                       if (((word >> 23) & 0x1) == 0)
   1806                                                         {
   1807                                                           if (((word >> 31) & 0x1) == 0)
   1808                                                             {
   1809                                                               if (((word >> 30) & 0x1) == 0)
   1810                                                                 {
   1811                                                                   /* 33222222222211111111110000000000
   1812                                                                      10987654321098765432109876543210
   1813                                                                      xxxxxxxxxx00110xxxxxx11000011100
   1814                                                                      ldsetlb.  */
   1815                                                                   return 1046;
   1816                                                                 }
   1817                                                               else
   1818                                                                 {
   1819                                                                   /* 33222222222211111111110000000000
   1820                                                                      10987654321098765432109876543210
   1821                                                                      xxxxxxxxxx00110xxxxxx11000011110
   1822                                                                      ldsetlh.  */
   1823                                                                   return 1049;
   1824                                                                 }
   1825                                                             }
   1826                                                           else
   1827                                                             {
   1828                                                               /* 33222222222211111111110000000000
   1829                                                                  10987654321098765432109876543210
   1830                                                                  xxxxxxxxxx00110xxxxxx110000111x1
   1831                                                                  ldsetl.  */
   1832                                                               return 1052;
   1833                                                             }
   1834                                                         }
   1835                                                       else
   1836                                                         {
   1837                                                           if (((word >> 31) & 0x1) == 0)
   1838                                                             {
   1839                                                               if (((word >> 30) & 0x1) == 0)
   1840                                                                 {
   1841                                                                   /* 33222222222211111111110000000000
   1842                                                                      10987654321098765432109876543210
   1843                                                                      xxxxxxxxxx00110xxxxxx11100011100
   1844                                                                      ldsetalb.  */
   1845                                                                   return 1047;
   1846                                                                 }
   1847                                                               else
   1848                                                                 {
   1849                                                                   /* 33222222222211111111110000000000
   1850                                                                      10987654321098765432109876543210
   1851                                                                      xxxxxxxxxx00110xxxxxx11100011110
   1852                                                                      ldsetalh.  */
   1853                                                                   return 1050;
   1854                                                                 }
   1855                                                             }
   1856                                                           else
   1857                                                             {
   1858                                                               /* 33222222222211111111110000000000
   1859                                                                  10987654321098765432109876543210
   1860                                                                  xxxxxxxxxx00110xxxxxx111000111x1
   1861                                                                  ldsetal.  */
   1862                                                               return 1053;
   1863                                                             }
   1864                                                         }
   1865                                                     }
   1866                                                 }
   1867                                               else
   1868                                                 {
   1869                                                   if (((word >> 22) & 0x1) == 0)
   1870                                                     {
   1871                                                       if (((word >> 23) & 0x1) == 0)
   1872                                                         {
   1873                                                           if (((word >> 31) & 0x1) == 0)
   1874                                                             {
   1875                                                               if (((word >> 30) & 0x1) == 0)
   1876                                                                 {
   1877                                                                   /* 33222222222211111111110000000000
   1878                                                                      10987654321098765432109876543210
   1879                                                                      xxxxxxxxxx00111xxxxxx10000011100
   1880                                                                      lduminb.  */
   1881                                                                   return 1090;
   1882                                                                 }
   1883                                                               else
   1884                                                                 {
   1885                                                                   /* 33222222222211111111110000000000
   1886                                                                      10987654321098765432109876543210
   1887                                                                      xxxxxxxxxx00111xxxxxx10000011110
   1888                                                                      lduminh.  */
   1889                                                                   return 1091;
   1890                                                                 }
   1891                                                             }
   1892                                                           else
   1893                                                             {
   1894                                                               /* 33222222222211111111110000000000
   1895                                                                  10987654321098765432109876543210
   1896                                                                  xxxxxxxxxx00111xxxxxx100000111x1
   1897                                                                  ldumin.  */
   1898                                                               return 1092;
   1899                                                             }
   1900                                                         }
   1901                                                       else
   1902                                                         {
   1903                                                           if (((word >> 31) & 0x1) == 0)
   1904                                                             {
   1905                                                               if (((word >> 30) & 0x1) == 0)
   1906                                                                 {
   1907                                                                   /* 33222222222211111111110000000000
   1908                                                                      10987654321098765432109876543210
   1909                                                                      xxxxxxxxxx00111xxxxxx10100011100
   1910                                                                      lduminab.  */
   1911                                                                   return 1093;
   1912                                                                 }
   1913                                                               else
   1914                                                                 {
   1915                                                                   /* 33222222222211111111110000000000
   1916                                                                      10987654321098765432109876543210
   1917                                                                      xxxxxxxxxx00111xxxxxx10100011110
   1918                                                                      lduminah.  */
   1919                                                                   return 1096;
   1920                                                                 }
   1921                                                             }
   1922                                                           else
   1923                                                             {
   1924                                                               /* 33222222222211111111110000000000
   1925                                                                  10987654321098765432109876543210
   1926                                                                  xxxxxxxxxx00111xxxxxx101000111x1
   1927                                                                  ldumina.  */
   1928                                                               return 1099;
   1929                                                             }
   1930                                                         }
   1931                                                     }
   1932                                                   else
   1933                                                     {
   1934                                                       if (((word >> 23) & 0x1) == 0)
   1935                                                         {
   1936                                                           if (((word >> 31) & 0x1) == 0)
   1937                                                             {
   1938                                                               if (((word >> 30) & 0x1) == 0)
   1939                                                                 {
   1940                                                                   /* 33222222222211111111110000000000
   1941                                                                      10987654321098765432109876543210
   1942                                                                      xxxxxxxxxx00111xxxxxx11000011100
   1943                                                                      lduminlb.  */
   1944                                                                   return 1094;
   1945                                                                 }
   1946                                                               else
   1947                                                                 {
   1948                                                                   /* 33222222222211111111110000000000
   1949                                                                      10987654321098765432109876543210
   1950                                                                      xxxxxxxxxx00111xxxxxx11000011110
   1951                                                                      lduminlh.  */
   1952                                                                   return 1097;
   1953                                                                 }
   1954                                                             }
   1955                                                           else
   1956                                                             {
   1957                                                               /* 33222222222211111111110000000000
   1958                                                                  10987654321098765432109876543210
   1959                                                                  xxxxxxxxxx00111xxxxxx110000111x1
   1960                                                                  lduminl.  */
   1961                                                               return 1100;
   1962                                                             }
   1963                                                         }
   1964                                                       else
   1965                                                         {
   1966                                                           if (((word >> 31) & 0x1) == 0)
   1967                                                             {
   1968                                                               if (((word >> 30) & 0x1) == 0)
   1969                                                                 {
   1970                                                                   /* 33222222222211111111110000000000
   1971                                                                      10987654321098765432109876543210
   1972                                                                      xxxxxxxxxx00111xxxxxx11100011100
   1973                                                                      lduminalb.  */
   1974                                                                   return 1095;
   1975                                                                 }
   1976                                                               else
   1977                                                                 {
   1978                                                                   /* 33222222222211111111110000000000
   1979                                                                      10987654321098765432109876543210
   1980                                                                      xxxxxxxxxx00111xxxxxx11100011110
   1981                                                                      lduminalh.  */
   1982                                                                   return 1098;
   1983                                                                 }
   1984                                                             }
   1985                                                           else
   1986                                                             {
   1987                                                               /* 33222222222211111111110000000000
   1988                                                                  10987654321098765432109876543210
   1989                                                                  xxxxxxxxxx00111xxxxxx111000111x1
   1990                                                                  lduminal.  */
   1991                                                               return 1101;
   1992                                                             }
   1993                                                         }
   1994                                                     }
   1995                                                 }
   1996                                             }
   1997                                         }
   1998                                     }
   1999                                 }
   2000                               else
   2001                                 {
   2002                                   if (((word >> 21) & 0x1) == 0)
   2003                                     {
   2004                                       if (((word >> 23) & 0x1) == 0)
   2005                                         {
   2006                                           if (((word >> 22) & 0x1) == 0)
   2007                                             {
   2008                                               if (((word >> 31) & 0x1) == 0)
   2009                                                 {
   2010                                                   if (((word >> 30) & 0x1) == 0)
   2011                                                     {
   2012                                                       /* 33222222222211111111110000000000
   2013                                                          10987654321098765432109876543210
   2014                                                          xxxxxxxxxx01xxxxxxxxx00000011100
   2015                                                          sttrb.  */
   2016                                                       return 887;
   2017                                                     }
   2018                                                   else
   2019                                                     {
   2020                                                       /* 33222222222211111111110000000000
   2021                                                          10987654321098765432109876543210
   2022                                                          xxxxxxxxxx01xxxxxxxxx00000011110
   2023                                                          sttrh.  */
   2024                                                       return 890;
   2025                                                     }
   2026                                                 }
   2027                                               else
   2028                                                 {
   2029                                                   /* 33222222222211111111110000000000
   2030                                                      10987654321098765432109876543210
   2031                                                      xxxxxxxxxx01xxxxxxxxx000000111x1
   2032                                                      sttr.  */
   2033                                                   return 893;
   2034                                                 }
   2035                                             }
   2036                                           else
   2037                                             {
   2038                                               if (((word >> 31) & 0x1) == 0)
   2039                                                 {
   2040                                                   if (((word >> 30) & 0x1) == 0)
   2041                                                     {
   2042                                                       /* 33222222222211111111110000000000
   2043                                                          10987654321098765432109876543210
   2044                                                          xxxxxxxxxx01xxxxxxxxx01000011100
   2045                                                          ldtrb.  */
   2046                                                       return 888;
   2047                                                     }
   2048                                                   else
   2049                                                     {
   2050                                                       /* 33222222222211111111110000000000
   2051                                                          10987654321098765432109876543210
   2052                                                          xxxxxxxxxx01xxxxxxxxx01000011110
   2053                                                          ldtrh.  */
   2054                                                       return 891;
   2055                                                     }
   2056                                                 }
   2057                                               else
   2058                                                 {
   2059                                                   /* 33222222222211111111110000000000
   2060                                                      10987654321098765432109876543210
   2061                                                      xxxxxxxxxx01xxxxxxxxx010000111x1
   2062                                                      ldtr.  */
   2063                                                   return 894;
   2064                                                 }
   2065                                             }
   2066                                         }
   2067                                       else
   2068                                         {
   2069                                           if (((word >> 30) & 0x1) == 0)
   2070                                             {
   2071                                               if (((word >> 31) & 0x1) == 0)
   2072                                                 {
   2073                                                   /* 33222222222211111111110000000000
   2074                                                      10987654321098765432109876543210
   2075                                                      xxxxxxxxxx01xxxxxxxxx0x100011100
   2076                                                      ldtrsb.  */
   2077                                                   return 889;
   2078                                                 }
   2079                                               else
   2080                                                 {
   2081                                                   /* 33222222222211111111110000000000
   2082                                                      10987654321098765432109876543210
   2083                                                      xxxxxxxxxx01xxxxxxxxx0x100011101
   2084                                                      ldtrsw.  */
   2085                                                   return 895;
   2086                                                 }
   2087                                             }
   2088                                           else
   2089                                             {
   2090                                               /* 33222222222211111111110000000000
   2091                                                  10987654321098765432109876543210
   2092                                                  xxxxxxxxxx01xxxxxxxxx0x10001111x
   2093                                                  ldtrsh.  */
   2094                                               return 892;
   2095                                             }
   2096                                         }
   2097                                     }
   2098                                   else
   2099                                     {
   2100                                       if (((word >> 23) & 0x1) == 0)
   2101                                         {
   2102                                           if (((word >> 22) & 0x1) == 0)
   2103                                             {
   2104                                               if (((word >> 31) & 0x1) == 0)
   2105                                                 {
   2106                                                   if (((word >> 30) & 0x1) == 0)
   2107                                                     {
   2108                                                       /* 33222222222211111111110000000000
   2109                                                          10987654321098765432109876543210
   2110                                                          xxxxxxxxxx01xxxxxxxxx10000011100
   2111                                                          strb.  */
   2112                                                       return 875;
   2113                                                     }
   2114                                                   else
   2115                                                     {
   2116                                                       /* 33222222222211111111110000000000
   2117                                                          10987654321098765432109876543210
   2118                                                          xxxxxxxxxx01xxxxxxxxx10000011110
   2119                                                          strh.  */
   2120                                                       return 880;
   2121                                                     }
   2122                                                 }
   2123                                               else
   2124                                                 {
   2125                                                   /* 33222222222211111111110000000000
   2126                                                      10987654321098765432109876543210
   2127                                                      xxxxxxxxxx01xxxxxxxxx100000111x1
   2128                                                      str.  */
   2129                                                   return 883;
   2130                                                 }
   2131                                             }
   2132                                           else
   2133                                             {
   2134                                               if (((word >> 31) & 0x1) == 0)
   2135                                                 {
   2136                                                   if (((word >> 30) & 0x1) == 0)
   2137                                                     {
   2138                                                       /* 33222222222211111111110000000000
   2139                                                          10987654321098765432109876543210
   2140                                                          xxxxxxxxxx01xxxxxxxxx11000011100
   2141                                                          ldrb.  */
   2142                                                       return 876;
   2143                                                     }
   2144                                                   else
   2145                                                     {
   2146                                                       /* 33222222222211111111110000000000
   2147                                                          10987654321098765432109876543210
   2148                                                          xxxxxxxxxx01xxxxxxxxx11000011110
   2149                                                          ldrh.  */
   2150                                                       return 881;
   2151                                                     }
   2152                                                 }
   2153                                               else
   2154                                                 {
   2155                                                   /* 33222222222211111111110000000000
   2156                                                      10987654321098765432109876543210
   2157                                                      xxxxxxxxxx01xxxxxxxxx110000111x1
   2158                                                      ldr.  */
   2159                                                   return 884;
   2160                                                 }
   2161                                             }
   2162                                         }
   2163                                       else
   2164                                         {
   2165                                           if (((word >> 30) & 0x1) == 0)
   2166                                             {
   2167                                               if (((word >> 31) & 0x1) == 0)
   2168                                                 {
   2169                                                   /* 33222222222211111111110000000000
   2170                                                      10987654321098765432109876543210
   2171                                                      xxxxxxxxxx01xxxxxxxxx1x100011100
   2172                                                      ldrsb.  */
   2173                                                   return 877;
   2174                                                 }
   2175                                               else
   2176                                                 {
   2177                                                   /* 33222222222211111111110000000000
   2178                                                      10987654321098765432109876543210
   2179                                                      xxxxxxxxxx01xxxxxxxxx1x100011101
   2180                                                      ldrsw.  */
   2181                                                   return 885;
   2182                                                 }
   2183                                             }
   2184                                           else
   2185                                             {
   2186                                               if (((word >> 31) & 0x1) == 0)
   2187                                                 {
   2188                                                   /* 33222222222211111111110000000000
   2189                                                      10987654321098765432109876543210
   2190                                                      xxxxxxxxxx01xxxxxxxxx1x100011110
   2191                                                      ldrsh.  */
   2192                                                   return 882;
   2193                                                 }
   2194                                               else
   2195                                                 {
   2196                                                   /* 33222222222211111111110000000000
   2197                                                      10987654321098765432109876543210
   2198                                                      xxxxxxxxxx01xxxxxxxxx1x100011111
   2199                                                      prfm.  */
   2200                                                   return 886;
   2201                                                 }
   2202                                             }
   2203                                         }
   2204                                     }
   2205                                 }
   2206                             }
   2207                           else
   2208                             {
   2209                               if (((word >> 21) & 0x1) == 0)
   2210                                 {
   2211                                   if (((word >> 23) & 0x1) == 0)
   2212                                     {
   2213                                       if (((word >> 22) & 0x1) == 0)
   2214                                         {
   2215                                           if (((word >> 31) & 0x1) == 0)
   2216                                             {
   2217                                               if (((word >> 30) & 0x1) == 0)
   2218                                                 {
   2219                                                   /* 33222222222211111111110000000000
   2220                                                      10987654321098765432109876543210
   2221                                                      xxxxxxxxxx1xxxxxxxxxx00000011100
   2222                                                      strb.  */
   2223                                                   return 852;
   2224                                                 }
   2225                                               else
   2226                                                 {
   2227                                                   /* 33222222222211111111110000000000
   2228                                                      10987654321098765432109876543210
   2229                                                      xxxxxxxxxx1xxxxxxxxxx00000011110
   2230                                                      strh.  */
   2231                                                   return 857;
   2232                                                 }
   2233                                             }
   2234                                           else
   2235                                             {
   2236                                               /* 33222222222211111111110000000000
   2237                                                  10987654321098765432109876543210
   2238                                                  xxxxxxxxxx1xxxxxxxxxx000000111x1
   2239                                                  str.  */
   2240                                               return 860;
   2241                                             }
   2242                                         }
   2243                                       else
   2244                                         {
   2245                                           if (((word >> 31) & 0x1) == 0)
   2246                                             {
   2247                                               if (((word >> 30) & 0x1) == 0)
   2248                                                 {
   2249                                                   /* 33222222222211111111110000000000
   2250                                                      10987654321098765432109876543210
   2251                                                      xxxxxxxxxx1xxxxxxxxxx01000011100
   2252                                                      ldrb.  */
   2253                                                   return 853;
   2254                                                 }
   2255                                               else
   2256                                                 {
   2257                                                   /* 33222222222211111111110000000000
   2258                                                      10987654321098765432109876543210
   2259                                                      xxxxxxxxxx1xxxxxxxxxx01000011110
   2260                                                      ldrh.  */
   2261                                                   return 858;
   2262                                                 }
   2263                                             }
   2264                                           else
   2265                                             {
   2266                                               /* 33222222222211111111110000000000
   2267                                                  10987654321098765432109876543210
   2268                                                  xxxxxxxxxx1xxxxxxxxxx010000111x1
   2269                                                  ldr.  */
   2270                                               return 861;
   2271                                             }
   2272                                         }
   2273                                     }
   2274                                   else
   2275                                     {
   2276                                       if (((word >> 30) & 0x1) == 0)
   2277                                         {
   2278                                           if (((word >> 31) & 0x1) == 0)
   2279                                             {
   2280                                               /* 33222222222211111111110000000000
   2281                                                  10987654321098765432109876543210
   2282                                                  xxxxxxxxxx1xxxxxxxxxx0x100011100
   2283                                                  ldrsb.  */
   2284                                               return 854;
   2285                                             }
   2286                                           else
   2287                                             {
   2288                                               /* 33222222222211111111110000000000
   2289                                                  10987654321098765432109876543210
   2290                                                  xxxxxxxxxx1xxxxxxxxxx0x100011101
   2291                                                  ldrsw.  */
   2292                                               return 862;
   2293                                             }
   2294                                         }
   2295                                       else
   2296                                         {
   2297                                           /* 33222222222211111111110000000000
   2298                                              10987654321098765432109876543210
   2299                                              xxxxxxxxxx1xxxxxxxxxx0x10001111x
   2300                                              ldrsh.  */
   2301                                           return 859;
   2302                                         }
   2303                                     }
   2304                                 }
   2305                               else
   2306                                 {
   2307                                   if (((word >> 23) & 0x1) == 0)
   2308                                     {
   2309                                       /* 33222222222211111111110000000000
   2310                                          10987654321098765432109876543210
   2311                                          xxxxxxxxxx1xxxxxxxxxx1x0000111xx
   2312                                          ldraa.  */
   2313                                       return 908;
   2314                                     }
   2315                                   else
   2316                                     {
   2317                                       /* 33222222222211111111110000000000
   2318                                          10987654321098765432109876543210
   2319                                          xxxxxxxxxx1xxxxxxxxxx1x1000111xx
   2320                                          ldrab.  */
   2321                                       return 909;
   2322                                     }
   2323                                 }
   2324                             }
   2325                         }
   2326                     }
   2327                   else
   2328                     {
   2329                       if (((word >> 23) & 0x1) == 0)
   2330                         {
   2331                           if (((word >> 22) & 0x1) == 0)
   2332                             {
   2333                               if (((word >> 31) & 0x1) == 0)
   2334                                 {
   2335                                   if (((word >> 30) & 0x1) == 0)
   2336                                     {
   2337                                       /* 33222222222211111111110000000000
   2338                                          10987654321098765432109876543210
   2339                                          xxxxxxxxxxxxxxxxxxxxxx0010011x00
   2340                                          strb.  */
   2341                                       return 863;
   2342                                     }
   2343                                   else
   2344                                     {
   2345                                       /* 33222222222211111111110000000000
   2346                                          10987654321098765432109876543210
   2347                                          xxxxxxxxxxxxxxxxxxxxxx0010011x10
   2348                                          strh.  */
   2349                                       return 868;
   2350                                     }
   2351                                 }
   2352                               else
   2353                                 {
   2354                                   /* 33222222222211111111110000000000
   2355                                      10987654321098765432109876543210
   2356                                      xxxxxxxxxxxxxxxxxxxxxx0010011xx1
   2357                                      str.  */
   2358                                   return 871;
   2359                                 }
   2360                             }
   2361                           else
   2362                             {
   2363                               if (((word >> 31) & 0x1) == 0)
   2364                                 {
   2365                                   if (((word >> 30) & 0x1) == 0)
   2366                                     {
   2367                                       /* 33222222222211111111110000000000
   2368                                          10987654321098765432109876543210
   2369                                          xxxxxxxxxxxxxxxxxxxxxx1010011x00
   2370                                          ldrb.  */
   2371                                       return 864;
   2372                                     }
   2373                                   else
   2374                                     {
   2375                                       /* 33222222222211111111110000000000
   2376                                          10987654321098765432109876543210
   2377                                          xxxxxxxxxxxxxxxxxxxxxx1010011x10
   2378                                          ldrh.  */
   2379                                       return 869;
   2380                                     }
   2381                                 }
   2382                               else
   2383                                 {
   2384                                   /* 33222222222211111111110000000000
   2385                                      10987654321098765432109876543210
   2386                                      xxxxxxxxxxxxxxxxxxxxxx1010011xx1
   2387                                      ldr.  */
   2388                                   return 872;
   2389                                 }
   2390                             }
   2391                         }
   2392                       else
   2393                         {
   2394                           if (((word >> 30) & 0x1) == 0)
   2395                             {
   2396                               if (((word >> 31) & 0x1) == 0)
   2397                                 {
   2398                                   /* 33222222222211111111110000000000
   2399                                      10987654321098765432109876543210
   2400                                      xxxxxxxxxxxxxxxxxxxxxxx110011x00
   2401                                      ldrsb.  */
   2402                                   return 865;
   2403                                 }
   2404                               else
   2405                                 {
   2406                                   /* 33222222222211111111110000000000
   2407                                      10987654321098765432109876543210
   2408                                      xxxxxxxxxxxxxxxxxxxxxxx110011x01
   2409                                      ldrsw.  */
   2410                                   return 873;
   2411                                 }
   2412                             }
   2413                           else
   2414                             {
   2415                               if (((word >> 31) & 0x1) == 0)
   2416                                 {
   2417                                   /* 33222222222211111111110000000000
   2418                                      10987654321098765432109876543210
   2419                                      xxxxxxxxxxxxxxxxxxxxxxx110011x10
   2420                                      ldrsh.  */
   2421                                   return 870;
   2422                                 }
   2423                               else
   2424                                 {
   2425                                   /* 33222222222211111111110000000000
   2426                                      10987654321098765432109876543210
   2427                                      xxxxxxxxxxxxxxxxxxxxxxx110011x11
   2428                                      prfm.  */
   2429                                   return 874;
   2430                                 }
   2431                             }
   2432                         }
   2433                     }
   2434                 }
   2435             }
   2436         }
   2437       else
   2438         {
   2439           if (((word >> 24) & 0x1) == 0)
   2440             {
   2441               if (((word >> 27) & 0x1) == 0)
   2442                 {
   2443                   if (((word >> 23) & 0x1) == 0)
   2444                     {
   2445                       if (((word >> 29) & 0x1) == 0)
   2446                         {
   2447                           if (((word >> 30) & 0x1) == 0)
   2448                             {
   2449                               /* 33222222222211111111110000000000
   2450                                  10987654321098765432109876543210
   2451                                  xxxxxxxxxxxxxxxxxxxxxxx00100x00x
   2452                                  and.  */
   2453                               return 959;
   2454                             }
   2455                           else
   2456                             {
   2457                               /* 33222222222211111111110000000000
   2458                                  10987654321098765432109876543210
   2459                                  xxxxxxxxxxxxxxxxxxxxxxx00100x01x
   2460                                  eor.  */
   2461                               return 963;
   2462                             }
   2463                         }
   2464                       else
   2465                         {
   2466                           if (((word >> 30) & 0x1) == 0)
   2467                             {
   2468                               /* 33222222222211111111110000000000
   2469                                  10987654321098765432109876543210
   2470                                  xxxxxxxxxxxxxxxxxxxxxxx00100x10x
   2471                                  orr.  */
   2472                               return 961;
   2473                             }
   2474                           else
   2475                             {
   2476                               /* 33222222222211111111110000000000
   2477                                  10987654321098765432109876543210
   2478                                  xxxxxxxxxxxxxxxxxxxxxxx00100x11x
   2479                                  ands.  */
   2480                               return 964;
   2481                             }
   2482                         }
   2483                     }
   2484                   else
   2485                     {
   2486                       if (((word >> 29) & 0x1) == 0)
   2487                         {
   2488                           if (((word >> 30) & 0x1) == 0)
   2489                             {
   2490                               /* 33222222222211111111110000000000
   2491                                  10987654321098765432109876543210
   2492                                  xxxxxxxxxxxxxxxxxxxxxxx10100x00x
   2493                                  movn.  */
   2494                               return 1150;
   2495                             }
   2496                           else
   2497                             {
   2498                               /* 33222222222211111111110000000000
   2499                                  10987654321098765432109876543210
   2500                                  xxxxxxxxxxxxxxxxxxxxxxx10100x01x
   2501                                  movz.  */
   2502                               return 1152;
   2503                             }
   2504                         }
   2505                       else
   2506                         {
   2507                           /* 33222222222211111111110000000000
   2508                              10987654321098765432109876543210
   2509                              xxxxxxxxxxxxxxxxxxxxxxx10100x1xx
   2510                              movk.  */
   2511                           return 1154;
   2512                         }
   2513                     }
   2514                 }
   2515               else
   2516                 {
   2517                   if (((word >> 21) & 0x1) == 0)
   2518                     {
   2519                       if (((word >> 28) & 0x1) == 0)
   2520                         {
   2521                           if (((word >> 29) & 0x1) == 0)
   2522                             {
   2523                               if (((word >> 30) & 0x1) == 0)
   2524                                 {
   2525                                   /* 33222222222211111111110000000000
   2526                                      10987654321098765432109876543210
   2527                                      xxxxxxxxxxxxxxxxxxxxx0xx0101000x
   2528                                      and.  */
   2529                                   return 966;
   2530                                 }
   2531                               else
   2532                                 {
   2533                                   /* 33222222222211111111110000000000
   2534                                      10987654321098765432109876543210
   2535                                      xxxxxxxxxxxxxxxxxxxxx0xx0101001x
   2536                                      eor.  */
   2537                                   return 973;
   2538                                 }
   2539                             }
   2540                           else
   2541                             {
   2542                               if (((word >> 30) & 0x1) == 0)
   2543                                 {
   2544                                   /* 33222222222211111111110000000000
   2545                                      10987654321098765432109876543210
   2546                                      xxxxxxxxxxxxxxxxxxxxx0xx0101010x
   2547                                      orr.  */
   2548                                   return 968;
   2549                                 }
   2550                               else
   2551                                 {
   2552                                   /* 33222222222211111111110000000000
   2553                                      10987654321098765432109876543210
   2554                                      xxxxxxxxxxxxxxxxxxxxx0xx0101011x
   2555                                      ands.  */
   2556                                   return 975;
   2557                                 }
   2558                             }
   2559                         }
   2560                       else
   2561                         {
   2562                           if (((word >> 10) & 0x1) == 0)
   2563                             {
   2564                               if (((word >> 11) & 0x1) == 0)
   2565                                 {
   2566                                   if (((word >> 22) & 0x1) == 0)
   2567                                     {
   2568                                       if (((word >> 23) & 0x1) == 0)
   2569                                         {
   2570                                           if (((word >> 29) & 0x1) == 0)
   2571                                             {
   2572                                               if (((word >> 30) & 0x1) == 0)
   2573                                                 {
   2574                                                   /* 33222222222211111111110000000000
   2575                                                      10987654321098765432109876543210
   2576                                                      xxxxxxxxxx00xxxxxxxxx0000101100x
   2577                                                      adc.  */
   2578                                                   return 0;
   2579                                                 }
   2580                                               else
   2581                                                 {
   2582                                                   /* 33222222222211111111110000000000
   2583                                                      10987654321098765432109876543210
   2584                                                      xxxxxxxxxx00xxxxxxxxx0000101101x
   2585                                                      sbc.  */
   2586                                                   return 2;
   2587                                                 }
   2588                                             }
   2589                                           else
   2590                                             {
   2591                                               if (((word >> 30) & 0x1) == 0)
   2592                                                 {
   2593                                                   /* 33222222222211111111110000000000
   2594                                                      10987654321098765432109876543210
   2595                                                      xxxxxxxxxx00xxxxxxxxx0000101110x
   2596                                                      adcs.  */
   2597                                                   return 1;
   2598                                                 }
   2599                                               else
   2600                                                 {
   2601                                                   /* 33222222222211111111110000000000
   2602                                                      10987654321098765432109876543210
   2603                                                      xxxxxxxxxx00xxxxxxxxx0000101111x
   2604                                                      sbcs.  */
   2605                                                   return 4;
   2606                                                 }
   2607                                             }
   2608                                         }
   2609                                       else
   2610                                         {
   2611                                           if (((word >> 30) & 0x1) == 0)
   2612                                             {
   2613                                               /* 33222222222211111111110000000000
   2614                                                  10987654321098765432109876543210
   2615                                                  xxxxxxxxxx00xxxxxxxxx00101011x0x
   2616                                                  csel.  */
   2617                                               return 656;
   2618                                             }
   2619                                           else
   2620                                             {
   2621                                               /* 33222222222211111111110000000000
   2622                                                  10987654321098765432109876543210
   2623                                                  xxxxxxxxxx00xxxxxxxxx00101011x1x
   2624                                                  csinv.  */
   2625                                               return 660;
   2626                                             }
   2627                                         }
   2628                                     }
   2629                                   else
   2630                                     {
   2631                                       if (((word >> 23) & 0x1) == 0)
   2632                                         {
   2633                                           if (((word >> 30) & 0x1) == 0)
   2634                                             {
   2635                                               /* 33222222222211111111110000000000
   2636                                                  10987654321098765432109876543210
   2637                                                  xxxxxxxxxx00xxxxxxxxx01001011x0x
   2638                                                  ccmn.  */
   2639                                               return 654;
   2640                                             }
   2641                                           else
   2642                                             {
   2643                                               /* 33222222222211111111110000000000
   2644                                                  10987654321098765432109876543210
   2645                                                  xxxxxxxxxx00xxxxxxxxx01001011x1x
   2646                                                  ccmp.  */
   2647                                               return 655;
   2648                                             }
   2649                                         }
   2650                                       else
   2651                                         {
   2652                                           if (((word >> 12) & 0x1) == 0)
   2653                                             {
   2654                                               if (((word >> 13) & 0x1) == 0)
   2655                                                 {
   2656                                                   if (((word >> 14) & 0x1) == 0)
   2657                                                     {
   2658                                                       if (((word >> 16) & 0x1) == 0)
   2659                                                         {
   2660                                                           /* 33222222222211111111110000000000
   2661                                                              10987654321098765432109876543210
   2662                                                              xxxxxxxxxx00000x0xxxx01101011xxx
   2663                                                              rbit.  */
   2664                                                           return 679;
   2665                                                         }
   2666                                                       else
   2667                                                         {
   2668                                                           /* 33222222222211111111110000000000
   2669                                                              10987654321098765432109876543210
   2670                                                              xxxxxxxxxx00000x1xxxx01101011xxx
   2671                                                              pacia.  */
   2672                                                           return 687;
   2673                                                         }
   2674                                                     }
   2675                                                   else
   2676                                                     {
   2677                                                       if (((word >> 30) & 0x1) == 0)
   2678                                                         {
   2679                                                           /* 33222222222211111111110000000000
   2680                                                              10987654321098765432109876543210
   2681                                                              xxxxxxxxxx00001xxxxxx01101011x0x
   2682                                                              crc32b.  */
   2683                                                           return 716;
   2684                                                         }
   2685                                                       else
   2686                                                         {
   2687                                                           /* 33222222222211111111110000000000
   2688                                                              10987654321098765432109876543210
   2689                                                              xxxxxxxxxx00001xxxxxx01101011x1x
   2690                                                              xpaci.  */
   2691                                                           return 703;
   2692                                                         }
   2693                                                     }
   2694                                                 }
   2695                                               else
   2696                                                 {
   2697                                                   if (((word >> 30) & 0x1) == 0)
   2698                                                     {
   2699                                                       /* 33222222222211111111110000000000
   2700                                                          10987654321098765432109876543210
   2701                                                          xxxxxxxxxx0001xxxxxxx01101011x0x
   2702                                                          lslv.  */
   2703                                                       return 707;
   2704                                                     }
   2705                                                   else
   2706                                                     {
   2707                                                       /* 33222222222211111111110000000000
   2708                                                          10987654321098765432109876543210
   2709                                                          xxxxxxxxxx0001xxxxxxx01101011x1x
   2710                                                          paciza.  */
   2711                                                       return 695;
   2712                                                     }
   2713                                                 }
   2714                                             }
   2715                                           else
   2716                                             {
   2717                                               if (((word >> 13) & 0x1) == 0)
   2718                                                 {
   2719                                                   if (((word >> 14) & 0x1) == 0)
   2720                                                     {
   2721                                                       if (((word >> 16) & 0x1) == 0)
   2722                                                         {
   2723                                                           /* 33222222222211111111110000000000
   2724                                                              10987654321098765432109876543210
   2725                                                              xxxxxxxxxx00100x0xxxx01101011xxx
   2726                                                              clz.  */
   2727                                                           return 684;
   2728                                                         }
   2729                                                       else
   2730                                                         {
   2731                                                           /* 33222222222211111111110000000000
   2732                                                              10987654321098765432109876543210
   2733                                                              xxxxxxxxxx00100x1xxxx01101011xxx
   2734                                                              autia.  */
   2735                                                           return 691;
   2736                                                         }
   2737                                                     }
   2738                                                   else
   2739                                                     {
   2740                                                       /* 33222222222211111111110000000000
   2741                                                          10987654321098765432109876543210
   2742                                                          xxxxxxxxxx00101xxxxxx01101011xxx
   2743                                                          crc32cb.  */
   2744                                                       return 720;
   2745                                                     }
   2746                                                 }
   2747                                               else
   2748                                                 {
   2749                                                   if (((word >> 30) & 0x1) == 0)
   2750                                                     {
   2751                                                       /* 33222222222211111111110000000000
   2752                                                          10987654321098765432109876543210
   2753                                                          xxxxxxxxxx0011xxxxxxx01101011x0x
   2754                                                          pacga.  */
   2755                                                       return 715;
   2756                                                     }
   2757                                                   else
   2758                                                     {
   2759                                                       /* 33222222222211111111110000000000
   2760                                                          10987654321098765432109876543210
   2761                                                          xxxxxxxxxx0011xxxxxxx01101011x1x
   2762                                                          autiza.  */
   2763                                                       return 699;
   2764                                                     }
   2765                                                 }
   2766                                             }
   2767                                         }
   2768                                     }
   2769                                 }
   2770                               else
   2771                                 {
   2772                                   if (((word >> 23) & 0x1) == 0)
   2773                                     {
   2774                                       if (((word >> 30) & 0x1) == 0)
   2775                                         {
   2776                                           /* 33222222222211111111110000000000
   2777                                              10987654321098765432109876543210
   2778                                              xxxxxxxxxx01xxxxxxxxx0x001011x0x
   2779                                              ccmn.  */
   2780                                           return 652;
   2781                                         }
   2782                                       else
   2783                                         {
   2784                                           /* 33222222222211111111110000000000
   2785                                              10987654321098765432109876543210
   2786                                              xxxxxxxxxx01xxxxxxxxx0x001011x1x
   2787                                              ccmp.  */
   2788                                           return 653;
   2789                                         }
   2790                                     }
   2791                                   else
   2792                                     {
   2793                                       if (((word >> 12) & 0x1) == 0)
   2794                                         {
   2795                                           if (((word >> 13) & 0x1) == 0)
   2796                                             {
   2797                                               if (((word >> 14) & 0x1) == 0)
   2798                                                 {
   2799                                                   if (((word >> 30) & 0x1) == 0)
   2800                                                     {
   2801                                                       /* 33222222222211111111110000000000
   2802                                                          10987654321098765432109876543210
   2803                                                          xxxxxxxxxx01000xxxxxx0x101011x0x
   2804                                                          udiv.  */
   2805                                                       return 705;
   2806                                                     }
   2807                                                   else
   2808                                                     {
   2809                                                       if (((word >> 16) & 0x1) == 0)
   2810                                                         {
   2811                                                           if (((word >> 31) & 0x1) == 0)
   2812                                                             {
   2813                                                               /* 33222222222211111111110000000000
   2814                                                                  10987654321098765432109876543210
   2815                                                                  xxxxxxxxxx01000x0xxxx0x101011x10
   2816                                                                  rev.  */
   2817                                                               return 681;
   2818                                                             }
   2819                                                           else
   2820                                                             {
   2821                                                               /* 33222222222211111111110000000000
   2822                                                                  10987654321098765432109876543210
   2823                                                                  xxxxxxxxxx01000x0xxxx0x101011x11
   2824                                                                  rev32.  */
   2825                                                               return 686;
   2826                                                             }
   2827                                                         }
   2828                                                       else
   2829                                                         {
   2830                                                           /* 33222222222211111111110000000000
   2831                                                              10987654321098765432109876543210
   2832                                                              xxxxxxxxxx01000x1xxxx0x101011x1x
   2833                                                              pacda.  */
   2834                                                           return 689;
   2835                                                         }
   2836                                                     }
   2837                                                 }
   2838                                               else
   2839                                                 {
   2840                                                   /* 33222222222211111111110000000000
   2841                                                      10987654321098765432109876543210
   2842                                                      xxxxxxxxxx01001xxxxxx0x101011xxx
   2843                                                      crc32w.  */
   2844                                                   return 718;
   2845                                                 }
   2846                                             }
   2847                                           else
   2848                                             {
   2849                                               if (((word >> 30) & 0x1) == 0)
   2850                                                 {
   2851                                                   /* 33222222222211111111110000000000
   2852                                                      10987654321098765432109876543210
   2853                                                      xxxxxxxxxx0101xxxxxxx0x101011x0x
   2854                                                      asrv.  */
   2855                                                   return 711;
   2856                                                 }
   2857                                               else
   2858                                                 {
   2859                                                   /* 33222222222211111111110000000000
   2860                                                      10987654321098765432109876543210
   2861                                                      xxxxxxxxxx0101xxxxxxx0x101011x1x
   2862                                                      pacdza.  */
   2863                                                   return 697;
   2864                                                 }
   2865                                             }
   2866                                         }
   2867                                       else
   2868                                         {
   2869                                           if (((word >> 13) & 0x1) == 0)
   2870                                             {
   2871                                               if (((word >> 14) & 0x1) == 0)
   2872                                                 {
   2873                                                   /* 33222222222211111111110000000000
   2874                                                      10987654321098765432109876543210
   2875                                                      xxxxxxxxxx01100xxxxxx0x101011xxx
   2876                                                      autda.  */
   2877                                                   return 693;
   2878                                                 }
   2879                                               else
   2880                                                 {
   2881                                                   /* 33222222222211111111110000000000
   2882                                                      10987654321098765432109876543210
   2883                                                      xxxxxxxxxx01101xxxxxx0x101011xxx
   2884                                                      crc32cw.  */
   2885                                                   return 722;
   2886                                                 }
   2887                                             }
   2888                                           else
   2889                                             {
   2890                                               /* 33222222222211111111110000000000
   2891                                                  10987654321098765432109876543210
   2892                                                  xxxxxxxxxx0111xxxxxxx0x101011xxx
   2893                                                  autdza.  */
   2894                                               return 701;
   2895                                             }
   2896                                         }
   2897                                     }
   2898                                 }
   2899                             }
   2900                           else
   2901                             {
   2902                               if (((word >> 11) & 0x1) == 0)
   2903                                 {
   2904                                   if (((word >> 22) & 0x1) == 0)
   2905                                     {
   2906                                       if (((word >> 30) & 0x1) == 0)
   2907                                         {
   2908                                           /* 33222222222211111111110000000000
   2909                                              10987654321098765432109876543210
   2910                                              xxxxxxxxxx10xxxxxxxxx00x01011x0x
   2911                                              csinc.  */
   2912                                           return 657;
   2913                                         }
   2914                                       else
   2915                                         {
   2916                                           /* 33222222222211111111110000000000
   2917                                              10987654321098765432109876543210
   2918                                              xxxxxxxxxx10xxxxxxxxx00x01011x1x
   2919                                              csneg.  */
   2920                                           return 663;
   2921                                         }
   2922                                     }
   2923                                   else
   2924                                     {
   2925                                       if (((word >> 12) & 0x1) == 0)
   2926                                         {
   2927                                           if (((word >> 13) & 0x1) == 0)
   2928                                             {
   2929                                               if (((word >> 14) & 0x1) == 0)
   2930                                                 {
   2931                                                   if (((word >> 16) & 0x1) == 0)
   2932                                                     {
   2933                                                       /* 33222222222211111111110000000000
   2934                                                          10987654321098765432109876543210
   2935                                                          xxxxxxxxxx10000x0xxxx01x01011xxx
   2936                                                          rev16.  */
   2937                                                       return 680;
   2938                                                     }
   2939                                                   else
   2940                                                     {
   2941                                                       /* 33222222222211111111110000000000
   2942                                                          10987654321098765432109876543210
   2943                                                          xxxxxxxxxx10000x1xxxx01x01011xxx
   2944                                                          pacib.  */
   2945                                                       return 688;
   2946                                                     }
   2947                                                 }
   2948                                               else
   2949                                                 {
   2950                                                   if (((word >> 30) & 0x1) == 0)
   2951                                                     {
   2952                                                       /* 33222222222211111111110000000000
   2953                                                          10987654321098765432109876543210
   2954                                                          xxxxxxxxxx10001xxxxxx01x01011x0x
   2955                                                          crc32h.  */
   2956                                                       return 717;
   2957                                                     }
   2958                                                   else
   2959                                                     {
   2960                                                       /* 33222222222211111111110000000000
   2961                                                          10987654321098765432109876543210
   2962                                                          xxxxxxxxxx10001xxxxxx01x01011x1x
   2963                                                          xpacd.  */
   2964                                                       return 704;
   2965                                                     }
   2966                                                 }
   2967                                             }
   2968                                           else
   2969                                             {
   2970                                               if (((word >> 30) & 0x1) == 0)
   2971                                                 {
   2972                                                   /* 33222222222211111111110000000000
   2973                                                      10987654321098765432109876543210
   2974                                                      xxxxxxxxxx1001xxxxxxx01x01011x0x
   2975                                                      lsrv.  */
   2976                                                   return 709;
   2977                                                 }
   2978                                               else
   2979                                                 {
   2980                                                   /* 33222222222211111111110000000000
   2981                                                      10987654321098765432109876543210
   2982                                                      xxxxxxxxxx1001xxxxxxx01x01011x1x
   2983                                                      pacizb.  */
   2984                                                   return 696;
   2985                                                 }
   2986                                             }
   2987                                         }
   2988                                       else
   2989                                         {
   2990                                           if (((word >> 13) & 0x1) == 0)
   2991                                             {
   2992                                               if (((word >> 14) & 0x1) == 0)
   2993                                                 {
   2994                                                   if (((word >> 16) & 0x1) == 0)
   2995                                                     {
   2996                                                       /* 33222222222211111111110000000000
   2997                                                          10987654321098765432109876543210
   2998                                                          xxxxxxxxxx10100x0xxxx01x01011xxx
   2999                                                          cls.  */
   3000                                                       return 685;
   3001                                                     }
   3002                                                   else
   3003                                                     {
   3004                                                       /* 33222222222211111111110000000000
   3005                                                          10987654321098765432109876543210
   3006                                                          xxxxxxxxxx10100x1xxxx01x01011xxx
   3007                                                          autib.  */
   3008                                                       return 692;
   3009                                                     }
   3010                                                 }
   3011                                               else
   3012                                                 {
   3013                                                   /* 33222222222211111111110000000000
   3014                                                      10987654321098765432109876543210
   3015                                                      xxxxxxxxxx10101xxxxxx01x01011xxx
   3016                                                      crc32ch.  */
   3017                                                   return 721;
   3018                                                 }
   3019                                             }
   3020                                           else
   3021                                             {
   3022                                               /* 33222222222211111111110000000000
   3023                                                  10987654321098765432109876543210
   3024                                                  xxxxxxxxxx1011xxxxxxx01x01011xxx
   3025                                                  autizb.  */
   3026                                               return 700;
   3027                                             }
   3028                                         }
   3029                                     }
   3030                                 }
   3031                               else
   3032                                 {
   3033                                   if (((word >> 12) & 0x1) == 0)
   3034                                     {
   3035                                       if (((word >> 13) & 0x1) == 0)
   3036                                         {
   3037                                           if (((word >> 14) & 0x1) == 0)
   3038                                             {
   3039                                               if (((word >> 30) & 0x1) == 0)
   3040                                                 {
   3041                                                   /* 33222222222211111111110000000000
   3042                                                      10987654321098765432109876543210
   3043                                                      xxxxxxxxxx11000xxxxxx0xx01011x0x
   3044                                                      sdiv.  */
   3045                                                   return 706;
   3046                                                 }
   3047                                               else
   3048                                                 {
   3049                                                   if (((word >> 16) & 0x1) == 0)
   3050                                                     {
   3051                                                       /* 33222222222211111111110000000000
   3052                                                          10987654321098765432109876543210
   3053                                                          xxxxxxxxxx11000x0xxxx0xx01011x1x
   3054                                                          rev.  */
   3055                                                       return 682;
   3056                                                     }
   3057                                                   else
   3058                                                     {
   3059                                                       /* 33222222222211111111110000000000
   3060                                                          10987654321098765432109876543210
   3061                                                          xxxxxxxxxx11000x1xxxx0xx01011x1x
   3062                                                          pacdb.  */
   3063                                                       return 690;
   3064                                                     }
   3065                                                 }
   3066                                             }
   3067                                           else
   3068                                             {
   3069                                               /* 33222222222211111111110000000000
   3070                                                  10987654321098765432109876543210
   3071                                                  xxxxxxxxxx11001xxxxxx0xx01011xxx
   3072                                                  crc32x.  */
   3073                                               return 719;
   3074                                             }
   3075                                         }
   3076                                       else
   3077                                         {
   3078                                           if (((word >> 30) & 0x1) == 0)
   3079                                             {
   3080                                               /* 33222222222211111111110000000000
   3081                                                  10987654321098765432109876543210
   3082                                                  xxxxxxxxxx1101xxxxxxx0xx01011x0x
   3083                                                  rorv.  */
   3084                                               return 713;
   3085                                             }
   3086                                           else
   3087                                             {
   3088                                               /* 33222222222211111111110000000000
   3089                                                  10987654321098765432109876543210
   3090                                                  xxxxxxxxxx1101xxxxxxx0xx01011x1x
   3091                                                  pacdzb.  */
   3092                                               return 698;
   3093                                             }
   3094                                         }
   3095                                     }
   3096                                   else
   3097                                     {
   3098                                       if (((word >> 13) & 0x1) == 0)
   3099                                         {
   3100                                           if (((word >> 14) & 0x1) == 0)
   3101                                             {
   3102                                               /* 33222222222211111111110000000000
   3103                                                  10987654321098765432109876543210
   3104                                                  xxxxxxxxxx11100xxxxxx0xx01011xxx
   3105                                                  autdb.  */
   3106                                               return 694;
   3107                                             }
   3108                                           else
   3109                                             {
   3110                                               /* 33222222222211111111110000000000
   3111                                                  10987654321098765432109876543210
   3112                                                  xxxxxxxxxx11101xxxxxx0xx01011xxx
   3113                                                  crc32cx.  */
   3114                                               return 723;
   3115                                             }
   3116                                         }
   3117                                       else
   3118                                         {
   3119                                           /* 33222222222211111111110000000000
   3120                                              10987654321098765432109876543210
   3121                                              xxxxxxxxxx1111xxxxxxx0xx01011xxx
   3122                                              autdzb.  */
   3123                                           return 702;
   3124                                         }
   3125                                     }
   3126                                 }
   3127                             }
   3128                         }
   3129                     }
   3130                   else
   3131                     {
   3132                       if (((word >> 29) & 0x1) == 0)
   3133                         {
   3134                           if (((word >> 30) & 0x1) == 0)
   3135                             {
   3136                               /* 33222222222211111111110000000000
   3137                                  10987654321098765432109876543210
   3138                                  xxxxxxxxxxxxxxxxxxxxx1xx0101x00x
   3139                                  bic.  */
   3140                               return 967;
   3141                             }
   3142                           else
   3143                             {
   3144                               /* 33222222222211111111110000000000
   3145                                  10987654321098765432109876543210
   3146                                  xxxxxxxxxxxxxxxxxxxxx1xx0101x01x
   3147                                  eon.  */
   3148                               return 974;
   3149                             }
   3150                         }
   3151                       else
   3152                         {
   3153                           if (((word >> 30) & 0x1) == 0)
   3154                             {
   3155                               /* 33222222222211111111110000000000
   3156                                  10987654321098765432109876543210
   3157                                  xxxxxxxxxxxxxxxxxxxxx1xx0101x10x
   3158                                  orn.  */
   3159                               return 971;
   3160                             }
   3161                           else
   3162                             {
   3163                               /* 33222222222211111111110000000000
   3164                                  10987654321098765432109876543210
   3165                                  xxxxxxxxxxxxxxxxxxxxx1xx0101x11x
   3166                                  bics.  */
   3167                               return 977;
   3168                             }
   3169                         }
   3170                     }
   3171                 }
   3172             }
   3173           else
   3174             {
   3175               if (((word >> 27) & 0x1) == 0)
   3176                 {
   3177                   if (((word >> 23) & 0x1) == 0)
   3178                     {
   3179                       if (((word >> 29) & 0x1) == 0)
   3180                         {
   3181                           if (((word >> 30) & 0x1) == 0)
   3182                             {
   3183                               /* 33222222222211111111110000000000
   3184                                  10987654321098765432109876543210
   3185                                  xxxxxxxxxxxxxxxxxxxxxxx01100x00x
   3186                                  sbfm.  */
   3187                               return 612;
   3188                             }
   3189                           else
   3190                             {
   3191                               /* 33222222222211111111110000000000
   3192                                  10987654321098765432109876543210
   3193                                  xxxxxxxxxxxxxxxxxxxxxxx01100x01x
   3194                                  ubfm.  */
   3195                               return 623;
   3196                             }
   3197                         }
   3198                       else
   3199                         {
   3200                           /* 33222222222211111111110000000000
   3201                              10987654321098765432109876543210
   3202                              xxxxxxxxxxxxxxxxxxxxxxx01100x1xx
   3203                              bfm.  */
   3204                           return 619;
   3205                         }
   3206                     }
   3207                   else
   3208                     {
   3209                       /* 33222222222211111111110000000000
   3210                          10987654321098765432109876543210
   3211                          xxxxxxxxxxxxxxxxxxxxxxx11100xxxx
   3212                          extr.  */
   3213                       return 746;
   3214                     }
   3215                 }
   3216               else
   3217                 {
   3218                   if (((word >> 21) & 0x1) == 0)
   3219                     {
   3220                       if (((word >> 28) & 0x1) == 0)
   3221                         {
   3222                           if (((word >> 29) & 0x1) == 0)
   3223                             {
   3224                               if (((word >> 30) & 0x1) == 0)
   3225                                 {
   3226                                   /* 33222222222211111111110000000000
   3227                                      10987654321098765432109876543210
   3228                                      xxxxxxxxxxxxxxxxxxxxx0xx1101000x
   3229                                      add.  */
   3230                                   return 19;
   3231                                 }
   3232                               else
   3233                                 {
   3234                                   /* 33222222222211111111110000000000
   3235                                      10987654321098765432109876543210
   3236                                      xxxxxxxxxxxxxxxxxxxxx0xx1101001x
   3237                                      sub.  */
   3238                                   return 22;
   3239                                 }
   3240                             }
   3241                           else
   3242                             {
   3243                               if (((word >> 30) & 0x1) == 0)
   3244                                 {
   3245                                   /* 33222222222211111111110000000000
   3246                                      10987654321098765432109876543210
   3247                                      xxxxxxxxxxxxxxxxxxxxx0xx1101010x
   3248                                      adds.  */
   3249                                   return 20;
   3250                                 }
   3251                               else
   3252                                 {
   3253                                   /* 33222222222211111111110000000000
   3254                                      10987654321098765432109876543210
   3255                                      xxxxxxxxxxxxxxxxxxxxx0xx1101011x
   3256                                      subs.  */
   3257                                   return 24;
   3258                                 }
   3259                             }
   3260                         }
   3261                       else
   3262                         {
   3263                           if (((word >> 15) & 0x1) == 0)
   3264                             {
   3265                               if (((word >> 22) & 0x1) == 0)
   3266                                 {
   3267                                   /* 33222222222211111111110000000000
   3268                                      10987654321098765432109876543210
   3269                                      xxxxxxxxxxxxxxx0xxxxx00x11011xxx
   3270                                      madd.  */
   3271                                   return 724;
   3272                                 }
   3273                               else
   3274                                 {
   3275                                   if (((word >> 23) & 0x1) == 0)
   3276                                     {
   3277                                       /* 33222222222211111111110000000000
   3278                                          10987654321098765432109876543210
   3279                                          xxxxxxxxxxxxxxx0xxxxx01011011xxx
   3280                                          smulh.  */
   3281                                       return 732;
   3282                                     }
   3283                                   else
   3284                                     {
   3285                                       /* 33222222222211111111110000000000
   3286                                          10987654321098765432109876543210
   3287                                          xxxxxxxxxxxxxxx0xxxxx01111011xxx
   3288                                          umulh.  */
   3289                                       return 737;
   3290                                     }
   3291                                 }
   3292                             }
   3293                           else
   3294                             {
   3295                               /* 33222222222211111111110000000000
   3296                                  10987654321098765432109876543210
   3297                                  xxxxxxxxxxxxxxx1xxxxx0xx11011xxx
   3298                                  msub.  */
   3299                               return 726;
   3300                             }
   3301                         }
   3302                     }
   3303                   else
   3304                     {
   3305                       if (((word >> 23) & 0x1) == 0)
   3306                         {
   3307                           if (((word >> 28) & 0x1) == 0)
   3308                             {
   3309                               if (((word >> 29) & 0x1) == 0)
   3310                                 {
   3311                                   if (((word >> 30) & 0x1) == 0)
   3312                                     {
   3313                                       /* 33222222222211111111110000000000
   3314                                          10987654321098765432109876543210
   3315                                          xxxxxxxxxxxxxxxxxxxxx1x01101000x
   3316                                          add.  */
   3317                                       return 6;
   3318                                     }
   3319                                   else
   3320                                     {
   3321                                       /* 33222222222211111111110000000000
   3322                                          10987654321098765432109876543210
   3323                                          xxxxxxxxxxxxxxxxxxxxx1x01101001x
   3324                                          sub.  */
   3325                                       return 9;
   3326                                     }
   3327                                 }
   3328                               else
   3329                                 {
   3330                                   if (((word >> 30) & 0x1) == 0)
   3331                                     {
   3332                                       /* 33222222222211111111110000000000
   3333                                          10987654321098765432109876543210
   3334                                          xxxxxxxxxxxxxxxxxxxxx1x01101010x
   3335                                          adds.  */
   3336                                       return 7;
   3337                                     }
   3338                                   else
   3339                                     {
   3340                                       /* 33222222222211111111110000000000
   3341                                          10987654321098765432109876543210
   3342                                          xxxxxxxxxxxxxxxxxxxxx1x01101011x
   3343                                          subs.  */
   3344                                       return 10;
   3345                                     }
   3346                                 }
   3347                             }
   3348                           else
   3349                             {
   3350                               if (((word >> 15) & 0x1) == 0)
   3351                                 {
   3352                                   /* 33222222222211111111110000000000
   3353                                      10987654321098765432109876543210
   3354                                      xxxxxxxxxxxxxxx0xxxxx1x011011xxx
   3355                                      smaddl.  */
   3356                                   return 728;
   3357                                 }
   3358                               else
   3359                                 {
   3360                                   /* 33222222222211111111110000000000
   3361                                      10987654321098765432109876543210
   3362                                      xxxxxxxxxxxxxxx1xxxxx1x011011xxx
   3363                                      smsubl.  */
   3364                                   return 730;
   3365                                 }
   3366                             }
   3367                         }
   3368                       else
   3369                         {
   3370                           if (((word >> 15) & 0x1) == 0)
   3371                             {
   3372                               /* 33222222222211111111110000000000
   3373                                  10987654321098765432109876543210
   3374                                  xxxxxxxxxxxxxxx0xxxxx1x11101xxxx
   3375                                  umaddl.  */
   3376                               return 733;
   3377                             }
   3378                           else
   3379                             {
   3380                               /* 33222222222211111111110000000000
   3381                                  10987654321098765432109876543210
   3382                                  xxxxxxxxxxxxxxx1xxxxx1x11101xxxx
   3383                                  umsubl.  */
   3384                               return 735;
   3385                             }
   3386                         }
   3387                     }
   3388                 }
   3389             }
   3390         }
   3391     }
   3392   else
   3393     {
   3394       if (((word >> 27) & 0x1) == 0)
   3395         {
   3396           if (((word >> 28) & 0x1) == 0)
   3397             {
   3398               if (((word >> 24) & 0x1) == 0)
   3399                 {
   3400                   if (((word >> 29) & 0x1) == 0)
   3401                     {
   3402                       if (((word >> 13) & 0x1) == 0)
   3403                         {
   3404                           if (((word >> 14) & 0x1) == 0)
   3405                             {
   3406                               if (((word >> 15) & 0x1) == 0)
   3407                                 {
   3408                                   if (((word >> 21) & 0x1) == 0)
   3409                                     {
   3410                                       if (((word >> 30) & 0x1) == 0)
   3411                                         {
   3412                                           if (((word >> 31) & 0x1) == 0)
   3413                                             {
   3414                                               if (((word >> 16) & 0x1) == 0)
   3415                                                 {
   3416                                                   if (((word >> 17) & 0x1) == 0)
   3417                                                     {
   3418                                                       if (((word >> 18) & 0x1) == 0)
   3419                                                         {
   3420                                                           if (((word >> 19) & 0x1) == 0)
   3421                                                             {
   3422                                                               if (((word >> 20) & 0x1) == 0)
   3423                                                                 {
   3424                                                                   /* 33222222222211111111110000000000
   3425                                                                      10987654321098765432109876543210
   3426                                                                      xxxxxxxxxxxxx000000000xx0x100000
   3427                                                                      add.  */
   3428                                                                   return 1232;
   3429                                                                 }
   3430                                                               else
   3431                                                                 {
   3432                                                                   /* 33222222222211111111110000000000
   3433                                                                      10987654321098765432109876543210
   3434                                                                      xxxxxxxxxxxxx000000010xx0x100000
   3435                                                                      mul.  */
   3436                                                                   return 1685;
   3437                                                                 }
   3438                                                             }
   3439                                                           else
   3440                                                             {
   3441                                                               if (((word >> 20) & 0x1) == 0)
   3442                                                                 {
   3443                                                                   /* 33222222222211111111110000000000
   3444                                                                      10987654321098765432109876543210
   3445                                                                      xxxxxxxxxxxxx000000100xx0x100000
   3446                                                                      smax.  */
   3447                                                                   return 1764;
   3448                                                                 }
   3449                                                               else
   3450                                                                 {
   3451                                                                   /* 33222222222211111111110000000000
   3452                                                                      10987654321098765432109876543210
   3453                                                                      xxxxxxxxxxxxx000000110xx0x100000
   3454                                                                      orr.  */
   3455                                                                   return 1696;
   3456                                                                 }
   3457                                                             }
   3458                                                         }
   3459                                                       else
   3460                                                         {
   3461                                                           if (((word >> 19) & 0x1) == 0)
   3462                                                             {
   3463                                                               /* 33222222222211111111110000000000
   3464                                                                  10987654321098765432109876543210
   3465                                                                  xxxxxxxxxxxxx0000010x0xx0x100000
   3466                                                                  sdiv.  */
   3467                                                               return 1755;
   3468                                                             }
   3469                                                           else
   3470                                                             {
   3471                                                               /* 33222222222211111111110000000000
   3472                                                                  10987654321098765432109876543210
   3473                                                                  xxxxxxxxxxxxx0000011x0xx0x100000
   3474                                                                  sabd.  */
   3475                                                               return 1746;
   3476                                                             }
   3477                                                         }
   3478                                                     }
   3479                                                   else
   3480                                                     {
   3481                                                       if (((word >> 18) & 0x1) == 0)
   3482                                                         {
   3483                                                           if (((word >> 19) & 0x1) == 0)
   3484                                                             {
   3485                                                               /* 33222222222211111111110000000000
   3486                                                                  10987654321098765432109876543210
   3487                                                                  xxxxxxxxxxxxx0000100x0xx0x100000
   3488                                                                  smulh.  */
   3489                                                               return 1769;
   3490                                                             }
   3491                                                           else
   3492                                                             {
   3493                                                               if (((word >> 20) & 0x1) == 0)
   3494                                                                 {
   3495                                                                   /* 33222222222211111111110000000000
   3496                                                                      10987654321098765432109876543210
   3497                                                                      xxxxxxxxxxxxx000010100xx0x100000
   3498                                                                      smin.  */
   3499                                                                   return 1767;
   3500                                                                 }
   3501                                                               else
   3502                                                                 {
   3503                                                                   /* 33222222222211111111110000000000
   3504                                                                      10987654321098765432109876543210
   3505                                                                      xxxxxxxxxxxxx000010110xx0x100000
   3506                                                                      and.  */
   3507                                                                   return 1240;
   3508                                                                 }
   3509                                                             }
   3510                                                         }
   3511                                                       else
   3512                                                         {
   3513                                                           /* 33222222222211111111110000000000
   3514                                                              10987654321098765432109876543210
   3515                                                              xxxxxxxxxxxxx000011xx0xx0x100000
   3516                                                              sdivr.  */
   3517                                                           return 1756;
   3518                                                         }
   3519                                                     }
   3520                                                 }
   3521                                               else
   3522                                                 {
   3523                                                   if (((word >> 17) & 0x1) == 0)
   3524                                                     {
   3525                                                       if (((word >> 18) & 0x1) == 0)
   3526                                                         {
   3527                                                           if (((word >> 19) & 0x1) == 0)
   3528                                                             {
   3529                                                               /* 33222222222211111111110000000000
   3530                                                                  10987654321098765432109876543210
   3531                                                                  xxxxxxxxxxxxx0001000x0xx0x100000
   3532                                                                  sub.  */
   3533                                                               return 1885;
   3534                                                             }
   3535                                                           else
   3536                                                             {
   3537                                                               if (((word >> 20) & 0x1) == 0)
   3538                                                                 {
   3539                                                                   /* 33222222222211111111110000000000
   3540                                                                      10987654321098765432109876543210
   3541                                                                      xxxxxxxxxxxxx000100100xx0x100000
   3542                                                                      umax.  */
   3543                                                                   return 1913;
   3544                                                                 }
   3545                                                               else
   3546                                                                 {
   3547                                                                   /* 33222222222211111111110000000000
   3548                                                                      10987654321098765432109876543210
   3549                                                                      xxxxxxxxxxxxx000100110xx0x100000
   3550                                                                      eor.  */
   3551                                                                   return 1327;
   3552                                                                 }
   3553                                                             }
   3554                                                         }
   3555                                                       else
   3556                                                         {
   3557                                                           if (((word >> 19) & 0x1) == 0)
   3558                                                             {
   3559                                                               /* 33222222222211111111110000000000
   3560                                                                  10987654321098765432109876543210
   3561                                                                  xxxxxxxxxxxxx0001010x0xx0x100000
   3562                                                                  udiv.  */
   3563                                                               return 1907;
   3564                                                             }
   3565                                                           else
   3566                                                             {
   3567                                                               /* 33222222222211111111110000000000
   3568                                                                  10987654321098765432109876543210
   3569                                                                  xxxxxxxxxxxxx0001011x0xx0x100000
   3570                                                                  uabd.  */
   3571                                                               return 1898;
   3572                                                             }
   3573                                                         }
   3574                                                     }
   3575                                                   else
   3576                                                     {
   3577                                                       if (((word >> 18) & 0x1) == 0)
   3578                                                         {
   3579                                                           if (((word >> 19) & 0x1) == 0)
   3580                                                             {
   3581                                                               if (((word >> 20) & 0x1) == 0)
   3582                                                                 {
   3583                                                                   /* 33222222222211111111110000000000
   3584                                                                      10987654321098765432109876543210
   3585                                                                      xxxxxxxxxxxxx000110000xx0x100000
   3586                                                                      subr.  */
   3587                                                                   return 1887;
   3588                                                                 }
   3589                                                               else
   3590                                                                 {
   3591                                                                   /* 33222222222211111111110000000000
   3592                                                                      10987654321098765432109876543210
   3593                                                                      xxxxxxxxxxxxx000110010xx0x100000
   3594                                                                      umulh.  */
   3595                                                                   return 1918;
   3596                                                                 }
   3597                                                             }
   3598                                                           else
   3599                                                             {
   3600                                                               if (((word >> 20) & 0x1) == 0)
   3601                                                                 {
   3602                                                                   /* 33222222222211111111110000000000
   3603                                                                      10987654321098765432109876543210
   3604                                                                      xxxxxxxxxxxxx000110100xx0x100000
   3605                                                                      umin.  */
   3606                                                                   return 1916;
   3607                                                                 }
   3608                                                               else
   3609                                                                 {
   3610                                                                   /* 33222222222211111111110000000000
   3611                                                                      10987654321098765432109876543210
   3612                                                                      xxxxxxxxxxxxx000110110xx0x100000
   3613                                                                      bic.  */
   3614                                                                   return 1252;
   3615                                                                 }
   3616                                                             }
   3617                                                         }
   3618                                                       else
   3619                                                         {
   3620                                                           /* 33222222222211111111110000000000
   3621                                                              10987654321098765432109876543210
   3622                                                              xxxxxxxxxxxxx000111xx0xx0x100000
   3623                                                              udivr.  */
   3624                                                           return 1908;
   3625                                                         }
   3626                                                     }
   3627                                                 }
   3628                                             }
   3629                                           else
   3630                                             {
   3631                                               if (((word >> 23) & 0x1) == 0)
   3632                                                 {
   3633                                                   /* 33222222222211111111110000000000
   3634                                                      10987654321098765432109876543210
   3635                                                      xxxxxxxxxxxxx000xxxxx0x00x100001
   3636                                                      ld1sb.  */
   3637                                                   return 1514;
   3638                                                 }
   3639                                               else
   3640                                                 {
   3641                                                   /* 33222222222211111111110000000000
   3642                                                      10987654321098765432109876543210
   3643                                                      xxxxxxxxxxxxx000xxxxx0x10x100001
   3644                                                      ld1sh.  */
   3645                                                   return 1525;
   3646                                                 }
   3647                                             }
   3648                                         }
   3649                                       else
   3650                                         {
   3651                                           if (((word >> 23) & 0x1) == 0)
   3652                                             {
   3653                                               /* 33222222222211111111110000000000
   3654                                                  10987654321098765432109876543210
   3655                                                  xxxxxxxxxxxxx000xxxxx0x00x10001x
   3656                                                  ld1sb.  */
   3657                                               return 1518;
   3658                                             }
   3659                                           else
   3660                                             {
   3661                                               if (((word >> 31) & 0x1) == 0)
   3662                                                 {
   3663                                                   if (((word >> 10) & 0x1) == 0)
   3664                                                     {
   3665                                                       /* 33222222222211111111110000000000
   3666                                                          10987654321098765432109876543210
   3667                                                          xxxxxxxxxx0xx000xxxxx0x10x100010
   3668                                                          sdot.  */
   3669                                                       return 1757;
   3670                                                     }
   3671                                                   else
   3672                                                     {
   3673                                                       /* 33222222222211111111110000000000
   3674                                                          10987654321098765432109876543210
   3675                                                          xxxxxxxxxx1xx000xxxxx0x10x100010
   3676                                                          udot.  */
   3677                                                       return 1909;
   3678                                                     }
   3679                                                 }
   3680                                               else
   3681                                                 {
   3682                                                   /* 33222222222211111111110000000000
   3683                                                      10987654321098765432109876543210
   3684                                                      xxxxxxxxxxxxx000xxxxx0x10x100011
   3685                                                      ld1sh.  */
   3686                                                   return 1529;
   3687                                                 }
   3688                                             }
   3689                                         }
   3690                                     }
   3691                                   else
   3692                                     {
   3693                                       if (((word >> 30) & 0x1) == 0)
   3694                                         {
   3695                                           if (((word >> 31) & 0x1) == 0)
   3696                                             {
   3697                                               if (((word >> 10) & 0x1) == 0)
   3698                                                 {
   3699                                                   if (((word >> 11) & 0x1) == 0)
   3700                                                     {
   3701                                                       if (((word >> 12) & 0x1) == 0)
   3702                                                         {
   3703                                                           /* 33222222222211111111110000000000
   3704                                                              10987654321098765432109876543210
   3705                                                              xxxxxxxxxx000000xxxxx1xx0x100000
   3706                                                              add.  */
   3707                                                           return 1230;
   3708                                                         }
   3709                                                       else
   3710                                                         {
   3711                                                           /* 33222222222211111111110000000000
   3712                                                              10987654321098765432109876543210
   3713                                                              xxxxxxxxxx001000xxxxx1xx0x100000
   3714                                                              sqadd.  */
   3715                                                           return 1771;
   3716                                                         }
   3717                                                     }
   3718                                                   else
   3719                                                     {
   3720                                                       /* 33222222222211111111110000000000
   3721                                                          10987654321098765432109876543210
   3722                                                          xxxxxxxxxx01x000xxxxx1xx0x100000
   3723                                                          sqsub.  */
   3724                                                       return 1801;
   3725                                                     }
   3726                                                 }
   3727                                               else
   3728                                                 {
   3729                                                   if (((word >> 11) & 0x1) == 0)
   3730                                                     {
   3731                                                       if (((word >> 12) & 0x1) == 0)
   3732                                                         {
   3733                                                           /* 33222222222211111111110000000000
   3734                                                              10987654321098765432109876543210
   3735                                                              xxxxxxxxxx100000xxxxx1xx0x100000
   3736                                                              sub.  */
   3737                                                           return 1883;
   3738                                                         }
   3739                                                       else
   3740                                                         {
   3741                                                           /* 33222222222211111111110000000000
   3742                                                              10987654321098765432109876543210
   3743                                                              xxxxxxxxxx101000xxxxx1xx0x100000
   3744                                                              uqadd.  */
   3745                                                           return 1919;
   3746                                                         }
   3747                                                     }
   3748                                                   else
   3749                                                     {
   3750                                                       /* 33222222222211111111110000000000
   3751                                                          10987654321098765432109876543210
   3752                                                          xxxxxxxxxx11x000xxxxx1xx0x100000
   3753                                                          uqsub.  */
   3754                                                       return 1949;
   3755                                                     }
   3756                                                 }
   3757                                             }
   3758                                           else
   3759                                             {
   3760                                               if (((word >> 23) & 0x1) == 0)
   3761                                                 {
   3762                                                   /* 33222222222211111111110000000000
   3763                                                      10987654321098765432109876543210
   3764                                                      xxxxxxxxxxxxx000xxxxx1x00x100001
   3765                                                      prfb.  */
   3766                                                   return 1704;
   3767                                                 }
   3768                                               else
   3769                                                 {
   3770                                                   /* 33222222222211111111110000000000
   3771                                                      10987654321098765432109876543210
   3772                                                      xxxxxxxxxxxxx000xxxxx1x10x100001
   3773                                                      ld1sh.  */
   3774                                                   return 1526;
   3775                                                 }
   3776                                             }
   3777                                         }
   3778                                       else
   3779                                         {
   3780                                           if (((word >> 23) & 0x1) == 0)
   3781                                             {
   3782                                               /* 33222222222211111111110000000000
   3783                                                  10987654321098765432109876543210
   3784                                                  xxxxxxxxxxxxx000xxxxx1x00x10001x
   3785                                                  prfb.  */
   3786                                               return 1705;
   3787                                             }
   3788                                           else
   3789                                             {
   3790                                               if (((word >> 31) & 0x1) == 0)
   3791                                                 {
   3792                                                   if (((word >> 10) & 0x1) == 0)
   3793                                                     {
   3794                                                       if (((word >> 22) & 0x1) == 0)
   3795                                                         {
   3796                                                           /* 33222222222211111111110000000000
   3797                                                              10987654321098765432109876543210
   3798                                                              xxxxxxxxxx0xx000xxxxx1010x100010
   3799                                                              sdot.  */
   3800                                                           return 1758;
   3801                                                         }
   3802                                                       else
   3803                                                         {
   3804                                                           /* 33222222222211111111110000000000
   3805                                                              10987654321098765432109876543210
   3806                                                              xxxxxxxxxx0xx000xxxxx1110x100010
   3807                                                              sdot.  */
   3808                                                           return 1759;
   3809                                                         }
   3810                                                     }
   3811                                                   else
   3812                                                     {
   3813                                                       if (((word >> 22) & 0x1) == 0)
   3814                                                         {
   3815                                                           /* 33222222222211111111110000000000
   3816                                                              10987654321098765432109876543210
   3817                                                              xxxxxxxxxx1xx000xxxxx1010x100010
   3818                                                              udot.  */
   3819                                                           return 1910;
   3820                                                         }
   3821                                                       else
   3822                                                         {
   3823                                                           /* 33222222222211111111110000000000
   3824                                                              10987654321098765432109876543210
   3825                                                              xxxxxxxxxx1xx000xxxxx1110x100010
   3826                                                              udot.  */
   3827                                                           return 1911;
   3828                                                         }
   3829                                                     }
   3830                                                 }
   3831                                               else
   3832                                                 {
   3833                                                   /* 33222222222211111111110000000000
   3834                                                      10987654321098765432109876543210
   3835                                                      xxxxxxxxxxxxx000xxxxx1x10x100011
   3836                                                      ld1sh.  */
   3837                                                   return 1530;
   3838                                                 }
   3839                                             }
   3840                                         }
   3841                                     }
   3842                                 }
   3843                               else
   3844                                 {
   3845                                   if (((word >> 30) & 0x1) == 0)
   3846                                     {
   3847                                       if (((word >> 31) & 0x1) == 0)
   3848                                         {
   3849                                           if (((word >> 21) & 0x1) == 0)
   3850                                             {
   3851                                               if (((word >> 16) & 0x1) == 0)
   3852                                                 {
   3853                                                   if (((word >> 18) & 0x1) == 0)
   3854                                                     {
   3855                                                       if (((word >> 19) & 0x1) == 0)
   3856                                                         {
   3857                                                           if (((word >> 20) & 0x1) == 0)
   3858                                                             {
   3859                                                               /* 33222222222211111111110000000000
   3860                                                                  10987654321098765432109876543210
   3861                                                                  xxxxxxxxxxxxx0010x0000xx0x100000
   3862                                                                  asr.  */
   3863                                                               return 1248;
   3864                                                             }
   3865                                                           else
   3866                                                             {
   3867                                                               /* 33222222222211111111110000000000
   3868                                                                  10987654321098765432109876543210
   3869                                                                  xxxxxxxxxxxxx0010x0010xx0x100000
   3870                                                                  asr.  */
   3871                                                               return 1246;
   3872                                                             }
   3873                                                         }
   3874                                                       else
   3875                                                         {
   3876                                                           /* 33222222222211111111110000000000
   3877                                                              10987654321098765432109876543210
   3878                                                              xxxxxxxxxxxxx0010x01x0xx0x100000
   3879                                                              asr.  */
   3880                                                           return 1247;
   3881                                                         }
   3882                                                     }
   3883                                                   else
   3884                                                     {
   3885                                                       if (((word >> 20) & 0x1) == 0)
   3886                                                         {
   3887                                                           /* 33222222222211111111110000000000
   3888                                                              10987654321098765432109876543210
   3889                                                              xxxxxxxxxxxxx0010x1x00xx0x100000
   3890                                                              asrd.  */
   3891                                                           return 1249;
   3892                                                         }
   3893                                                       else
   3894                                                         {
   3895                                                           /* 33222222222211111111110000000000
   3896                                                              10987654321098765432109876543210
   3897                                                              xxxxxxxxxxxxx0010x1x10xx0x100000
   3898                                                              asrr.  */
   3899                                                           return 1250;
   3900                                                         }
   3901                                                     }
   3902                                                 }
   3903                                               else
   3904                                                 {
   3905                                                   if (((word >> 17) & 0x1) == 0)
   3906                                                     {
   3907                                                       if (((word >> 18) & 0x1) == 0)
   3908                                                         {
   3909                                                           if (((word >> 19) & 0x1) == 0)
   3910                                                             {
   3911                                                               if (((word >> 20) & 0x1) == 0)
   3912                                                                 {
   3913                                                                   /* 33222222222211111111110000000000
   3914                                                                      10987654321098765432109876543210
   3915                                                                      xxxxxxxxxxxxx001100000xx0x100000
   3916                                                                      lsr.  */
   3917                                                                   return 1676;
   3918                                                                 }
   3919                                                               else
   3920                                                                 {
   3921                                                                   /* 33222222222211111111110000000000
   3922                                                                      10987654321098765432109876543210
   3923                                                                      xxxxxxxxxxxxx001100010xx0x100000
   3924                                                                      lsr.  */
   3925                                                                   return 1674;
   3926                                                                 }
   3927                                                             }
   3928                                                           else
   3929                                                             {
   3930                                                               /* 33222222222211111111110000000000
   3931                                                                  10987654321098765432109876543210
   3932                                                                  xxxxxxxxxxxxx0011001x0xx0x100000
   3933                                                                  lsr.  */
   3934                                                               return 1675;
   3935                                                             }
   3936                                                         }
   3937                                                       else
   3938                                                         {
   3939                                                           /* 33222222222211111111110000000000
   3940                                                              10987654321098765432109876543210
   3941                                                              xxxxxxxxxxxxx001101xx0xx0x100000
   3942                                                              lsrr.  */
   3943                                                           return 1677;
   3944                                                         }
   3945                                                     }
   3946                                                   else
   3947                                                     {
   3948                                                       if (((word >> 18) & 0x1) == 0)
   3949                                                         {
   3950                                                           if (((word >> 19) & 0x1) == 0)
   3951                                                             {
   3952                                                               if (((word >> 20) & 0x1) == 0)
   3953                                                                 {
   3954                                                                   /* 33222222222211111111110000000000
   3955                                                                      10987654321098765432109876543210
   3956                                                                      xxxxxxxxxxxxx001110000xx0x100000
   3957                                                                      lsl.  */
   3958                                                                   return 1670;
   3959                                                                 }
   3960                                                               else
   3961                                                                 {
   3962                                                                   /* 33222222222211111111110000000000
   3963                                                                      10987654321098765432109876543210
   3964                                                                      xxxxxxxxxxxxx001110010xx0x100000
   3965                                                                      lsl.  */
   3966                                                                   return 1668;
   3967                                                                 }
   3968                                                             }
   3969                                                           else
   3970                                                             {
   3971                                                               /* 33222222222211111111110000000000
   3972                                                                  10987654321098765432109876543210
   3973                                                                  xxxxxxxxxxxxx0011101x0xx0x100000
   3974                                                                  lsl.  */
   3975                                                               return 1669;
   3976                                                             }
   3977                                                         }
   3978                                                       else
   3979                                                         {
   3980                                                           /* 33222222222211111111110000000000
   3981                                                              10987654321098765432109876543210
   3982                                                              xxxxxxxxxxxxx001111xx0xx0x100000
   3983                                                              lslr.  */
   3984                                                           return 1671;
   3985                                                         }
   3986                                                     }
   3987                                                 }
   3988                                             }
   3989                                           else
   3990                                             {
   3991                                               if (((word >> 10) & 0x1) == 0)
   3992                                                 {
   3993                                                   if (((word >> 12) & 0x1) == 0)
   3994                                                     {
   3995                                                       /* 33222222222211111111110000000000
   3996                                                          10987654321098765432109876543210
   3997                                                          xxxxxxxxxx0x0001xxxxx1xx0x100000
   3998                                                          asr.  */
   3999                                                       return 1244;
   4000                                                     }
   4001                                                   else
   4002                                                     {
   4003                                                       /* 33222222222211111111110000000000
   4004                                                          10987654321098765432109876543210
   4005                                                          xxxxxxxxxx0x1001xxxxx1xx0x100000
   4006                                                          asr.  */
   4007                                                       return 1245;
   4008                                                     }
   4009                                                 }
   4010                                               else
   4011                                                 {
   4012                                                   if (((word >> 11) & 0x1) == 0)
   4013                                                     {
   4014                                                       if (((word >> 12) & 0x1) == 0)
   4015                                                         {
   4016                                                           /* 33222222222211111111110000000000
   4017                                                              10987654321098765432109876543210
   4018                                                              xxxxxxxxxx100001xxxxx1xx0x100000
   4019                                                              lsr.  */
   4020                                                           return 1672;
   4021                                                         }
   4022                                                       else
   4023                                                         {
   4024                                                           /* 33222222222211111111110000000000
   4025                                                              10987654321098765432109876543210
   4026                                                              xxxxxxxxxx101001xxxxx1xx0x100000
   4027                                                              lsr.  */
   4028                                                           return 1673;
   4029                                                         }
   4030                                                     }
   4031                                                   else
   4032                                                     {
   4033                                                       if (((word >> 12) & 0x1) == 0)
   4034                                                         {
   4035                                                           /* 33222222222211111111110000000000
   4036                                                              10987654321098765432109876543210
   4037                                                              xxxxxxxxxx110001xxxxx1xx0x100000
   4038                                                              lsl.  */
   4039                                                           return 1666;
   4040                                                         }
   4041                                                       else
   4042                                                         {
   4043                                                           /* 33222222222211111111110000000000
   4044                                                              10987654321098765432109876543210
   4045                                                              xxxxxxxxxx111001xxxxx1xx0x100000
   4046                                                              lsl.  */
   4047                                                           return 1667;
   4048                                                         }
   4049                                                     }
   4050                                                 }
   4051                                             }
   4052                                         }
   4053                                       else
   4054                                         {
   4055                                           if (((word >> 22) & 0x1) == 0)
   4056                                             {
   4057                                               if (((word >> 23) & 0x1) == 0)
   4058                                                 {
   4059                                                   /* 33222222222211111111110000000000
   4060                                                      10987654321098765432109876543210
   4061                                                      xxxxxxxxxxxxx001xxxxxx000x100001
   4062                                                      ld1sb.  */
   4063                                                   return 1520;
   4064                                                 }
   4065                                               else
   4066                                                 {
   4067                                                   /* 33222222222211111111110000000000
   4068                                                      10987654321098765432109876543210
   4069                                                      xxxxxxxxxxxxx001xxxxxx010x100001
   4070                                                      ld1sh.  */
   4071                                                   return 1533;
   4072                                                 }
   4073                                             }
   4074                                           else
   4075                                             {
   4076                                               if (((word >> 23) & 0x1) == 0)
   4077                                                 {
   4078                                                   /* 33222222222211111111110000000000
   4079                                                      10987654321098765432109876543210
   4080                                                      xxxxxxxxxxxxx001xxxxxx100x100001
   4081                                                      ld1rb.  */
   4082                                                   return 1490;
   4083                                                 }
   4084                                               else
   4085                                                 {
   4086                                                   /* 33222222222211111111110000000000
   4087                                                      10987654321098765432109876543210
   4088                                                      xxxxxxxxxxxxx001xxxxxx110x100001
   4089                                                      ld1rsw.  */
   4090                                                   return 1511;
   4091                                                 }
   4092                                             }
   4093                                         }
   4094                                     }
   4095                                   else
   4096                                     {
   4097                                       if (((word >> 21) & 0x1) == 0)
   4098                                         {
   4099                                           if (((word >> 23) & 0x1) == 0)
   4100                                             {
   4101                                               /* 33222222222211111111110000000000
   4102                                                  10987654321098765432109876543210
   4103                                                  xxxxxxxxxxxxx001xxxxx0x00x10001x
   4104                                                  ld1sb.  */
   4105                                               return 1519;
   4106                                             }
   4107                                           else
   4108                                             {
   4109                                               /* 33222222222211111111110000000000
   4110                                                  10987654321098765432109876543210
   4111                                                  xxxxxxxxxxxxx001xxxxx0x10x10001x
   4112                                                  ld1sh.  */
   4113                                               return 1531;
   4114                                             }
   4115                                         }
   4116                                       else
   4117                                         {
   4118                                           if (((word >> 22) & 0x1) == 0)
   4119                                             {
   4120                                               if (((word >> 23) & 0x1) == 0)
   4121                                                 {
   4122                                                   /* 33222222222211111111110000000000
   4123                                                      10987654321098765432109876543210
   4124                                                      xxxxxxxxxxxxx001xxxxx1000x10001x
   4125                                                      ld1sb.  */
   4126                                                   return 1524;
   4127                                                 }
   4128                                               else
   4129                                                 {
   4130                                                   /* 33222222222211111111110000000000
   4131                                                      10987654321098765432109876543210
   4132                                                      xxxxxxxxxxxxx001xxxxx1010x10001x
   4133                                                      ld1sh.  */
   4134                                                   return 1536;
   4135                                                 }
   4136                                             }
   4137                                           else
   4138                                             {
   4139                                               if (((word >> 23) & 0x1) == 0)
   4140                                                 {
   4141                                                   /* 33222222222211111111110000000000
   4142                                                      10987654321098765432109876543210
   4143                                                      xxxxxxxxxxxxx001xxxxx1100x10001x
   4144                                                      prfb.  */
   4145                                                   return 1706;
   4146                                                 }
   4147                                               else
   4148                                                 {
   4149                                                   /* 33222222222211111111110000000000
   4150                                                      10987654321098765432109876543210
   4151                                                      xxxxxxxxxxxxx001xxxxx1110x10001x
   4152                                                      ld1sh.  */
   4153                                                   return 1532;
   4154                                                 }
   4155                                             }
   4156                                         }
   4157                                     }
   4158                                 }
   4159                             }
   4160                           else
   4161                             {
   4162                               if (((word >> 15) & 0x1) == 0)
   4163                                 {
   4164                                   if (((word >> 21) & 0x1) == 0)
   4165                                     {
   4166                                       if (((word >> 30) & 0x1) == 0)
   4167                                         {
   4168                                           if (((word >> 31) & 0x1) == 0)
   4169                                             {
   4170                                               /* 33222222222211111111110000000000
   4171                                                  10987654321098765432109876543210
   4172                                                  xxxxxxxxxxxxx010xxxxx0xx0x100000
   4173                                                  mla.  */
   4174                                               return 1679;
   4175                                             }
   4176                                           else
   4177                                             {
   4178                                               if (((word >> 23) & 0x1) == 0)
   4179                                                 {
   4180                                                   /* 33222222222211111111110000000000
   4181                                                      10987654321098765432109876543210
   4182                                                      xxxxxxxxxxxxx010xxxxx0x00x100001
   4183                                                      ld1b.  */
   4184                                                   return 1456;
   4185                                                 }
   4186                                               else
   4187                                                 {
   4188                                                   /* 33222222222211111111110000000000
   4189                                                      10987654321098765432109876543210
   4190                                                      xxxxxxxxxxxxx010xxxxx0x10x100001
   4191                                                      ld1h.  */
   4192                                                   return 1476;
   4193                                                 }
   4194                                             }
   4195                                         }
   4196                                       else
   4197                                         {
   4198                                           if (((word >> 23) & 0x1) == 0)
   4199                                             {
   4200                                               /* 33222222222211111111110000000000
   4201                                                  10987654321098765432109876543210
   4202                                                  xxxxxxxxxxxxx010xxxxx0x00x10001x
   4203                                                  ld1b.  */
   4204                                               return 1461;
   4205                                             }
   4206                                           else
   4207                                             {
   4208                                               /* 33222222222211111111110000000000
   4209                                                  10987654321098765432109876543210
   4210                                                  xxxxxxxxxxxxx010xxxxx0x10x10001x
   4211                                                  ld1h.  */
   4212                                               return 1481;
   4213                                             }
   4214                                         }
   4215                                     }
   4216                                   else
   4217                                     {
   4218                                       if (((word >> 30) & 0x1) == 0)
   4219                                         {
   4220                                           if (((word >> 31) & 0x1) == 0)
   4221                                             {
   4222                                               if (((word >> 11) & 0x1) == 0)
   4223                                                 {
   4224                                                   if (((word >> 12) & 0x1) == 0)
   4225                                                     {
   4226                                                       if (((word >> 10) & 0x1) == 0)
   4227                                                         {
   4228                                                           /* 33222222222211111111110000000000
   4229                                                              10987654321098765432109876543210
   4230                                                              xxxxxxxxxx000010xxxxx1xx0x100000
   4231                                                              index.  */
   4232                                                           return 1447;
   4233                                                         }
   4234                                                       else
   4235                                                         {
   4236                                                           /* 33222222222211111111110000000000
   4237                                                              10987654321098765432109876543210
   4238                                                              xxxxxxxxxx100010xxxxx1xx0x100000
   4239                                                              index.  */
   4240                                                           return 1448;
   4241                                                         }
   4242                                                     }
   4243                                                   else
   4244                                                     {
   4245                                                       if (((word >> 22) & 0x1) == 0)
   4246                                                         {
   4247                                                           if (((word >> 23) & 0x1) == 0)
   4248                                                             {
   4249                                                               /* 33222222222211111111110000000000
   4250                                                                  10987654321098765432109876543210
   4251                                                                  xxxxxxxxxxx01010xxxxx1000x100000
   4252                                                                  addvl.  */
   4253                                                               return 1234;
   4254                                                             }
   4255                                                           else
   4256                                                             {
   4257                                                               /* 33222222222211111111110000000000
   4258                                                                  10987654321098765432109876543210
   4259                                                                  xxxxxxxxxxx01010xxxxx1010x100000
   4260                                                                  rdvl.  */
   4261                                                               return 1740;
   4262                                                             }
   4263                                                         }
   4264                                                       else
   4265                                                         {
   4266                                                           /* 33222222222211111111110000000000
   4267                                                              10987654321098765432109876543210
   4268                                                              xxxxxxxxxxx01010xxxxx11x0x100000
   4269                                                              addpl.  */
   4270                                                           return 1233;
   4271                                                         }
   4272                                                     }
   4273                                                 }
   4274                                               else
   4275                                                 {
   4276                                                   if (((word >> 10) & 0x1) == 0)
   4277                                                     {
   4278                                                       /* 33222222222211111111110000000000
   4279                                                          10987654321098765432109876543210
   4280                                                          xxxxxxxxxx01x010xxxxx1xx0x100000
   4281                                                          index.  */
   4282                                                       return 1449;
   4283                                                     }
   4284                                                   else
   4285                                                     {
   4286                                                       /* 33222222222211111111110000000000
   4287                                                          10987654321098765432109876543210
   4288                                                          xxxxxxxxxx11x010xxxxx1xx0x100000
   4289                                                          index.  */
   4290                                                       return 1446;
   4291                                                     }
   4292                                                 }
   4293                                             }
   4294                                           else
   4295                                             {
   4296                                               if (((word >> 23) & 0x1) == 0)
   4297                                                 {
   4298                                                   /* 33222222222211111111110000000000
   4299                                                      10987654321098765432109876543210
   4300                                                      xxxxxxxxxxxxx010xxxxx1x00x100001
   4301                                                      prfw.  */
   4302                                                   return 1724;
   4303                                                 }
   4304                                               else
   4305                                                 {
   4306                                                   /* 33222222222211111111110000000000
   4307                                                      10987654321098765432109876543210
   4308                                                      xxxxxxxxxxxxx010xxxxx1x10x100001
   4309                                                      ld1h.  */
   4310                                                   return 1477;
   4311                                                 }
   4312                                             }
   4313                                         }
   4314                                       else
   4315                                         {
   4316                                           if (((word >> 23) & 0x1) == 0)
   4317                                             {
   4318                                               /* 33222222222211111111110000000000
   4319                                                  10987654321098765432109876543210
   4320                                                  xxxxxxxxxxxxx010xxxxx1x00x10001x
   4321                                                  prfw.  */
   4322                                               return 1726;
   4323                                             }
   4324                                           else
   4325                                             {
   4326                                               /* 33222222222211111111110000000000
   4327                                                  10987654321098765432109876543210
   4328                                                  xxxxxxxxxxxxx010xxxxx1x10x10001x
   4329                                                  ld1h.  */
   4330                                               return 1482;
   4331                                             }
   4332                                         }
   4333                                     }
   4334                                 }
   4335                               else
   4336                                 {
   4337                                   if (((word >> 30) & 0x1) == 0)
   4338                                     {
   4339                                       if (((word >> 31) & 0x1) == 0)
   4340                                         {
   4341                                           if (((word >> 21) & 0x1) == 0)
   4342                                             {
   4343                                               /* 33222222222211111111110000000000
   4344                                                  10987654321098765432109876543210
   4345                                                  xxxxxxxxxxxxx011xxxxx0xx0x100000
   4346                                                  mad.  */
   4347                                               return 1678;
   4348                                             }
   4349                                           else
   4350                                             {
   4351                                               if (((word >> 10) & 0x1) == 0)
   4352                                                 {
   4353                                                   if (((word >> 11) & 0x1) == 0)
   4354                                                     {
   4355                                                       if (((word >> 20) & 0x1) == 0)
   4356                                                         {
   4357                                                           if (((word >> 22) & 0x1) == 0)
   4358                                                             {
   4359                                                               /* 33222222222211111111110000000000
   4360                                                                  10987654321098765432109876543210
   4361                                                                  xxxxxxxxxx00x011xxxx010x0x100000
   4362                                                                  sqincw.  */
   4363                                                               return 1798;
   4364                                                             }
   4365                                                           else
   4366                                                             {
   4367                                                               if (((word >> 23) & 0x1) == 0)
   4368                                                                 {
   4369                                                                   /* 33222222222211111111110000000000
   4370                                                                      10987654321098765432109876543210
   4371                                                                      xxxxxxxxxx00x011xxxx01100x100000
   4372                                                                      sqinch.  */
   4373                                                                   return 1792;
   4374                                                                 }
   4375                                                               else
   4376                                                                 {
   4377                                                                   /* 33222222222211111111110000000000
   4378                                                                      10987654321098765432109876543210
   4379                                                                      xxxxxxxxxx00x011xxxx01110x100000
   4380                                                                      sqincd.  */
   4381                                                                   return 1789;
   4382                                                                 }
   4383                                                             }
   4384                                                         }
   4385                                                       else
   4386                                                         {
   4387                                                           if (((word >> 22) & 0x1) == 0)
   4388                                                             {
   4389                                                               /* 33222222222211111111110000000000
   4390                                                                  10987654321098765432109876543210
   4391                                                                  xxxxxxxxxx00x011xxxx110x0x100000
   4392                                                                  incw.  */
   4393                                                               return 1444;
   4394                                                             }
   4395                                                           else
   4396                                                             {
   4397                                                               if (((word >> 23) & 0x1) == 0)
   4398                                                                 {
   4399                                                                   /* 33222222222211111111110000000000
   4400                                                                      10987654321098765432109876543210
   4401                                                                      xxxxxxxxxx00x011xxxx11100x100000
   4402                                                                      inch.  */
   4403                                                                   return 1440;
   4404                                                                 }
   4405                                                               else
   4406                                                                 {
   4407                                                                   /* 33222222222211111111110000000000
   4408                                                                      10987654321098765432109876543210
   4409                                                                      xxxxxxxxxx00x011xxxx11110x100000
   4410                                                                      incd.  */
   4411                                                                   return 1438;
   4412                                                                 }
   4413                                                             }
   4414                                                         }
   4415                                                     }
   4416                                                   else
   4417                                                     {
   4418                                                       if (((word >> 22) & 0x1) == 0)
   4419                                                         {
   4420                                                           /* 33222222222211111111110000000000
   4421                                                              10987654321098765432109876543210
   4422                                                              xxxxxxxxxx01x011xxxxx10x0x100000
   4423                                                              sqdecw.  */
   4424                                                           return 1784;
   4425                                                         }
   4426                                                       else
   4427                                                         {
   4428                                                           if (((word >> 23) & 0x1) == 0)
   4429                                                             {
   4430                                                               /* 33222222222211111111110000000000
   4431                                                                  10987654321098765432109876543210
   4432                                                                  xxxxxxxxxx01x011xxxxx1100x100000
   4433                                                                  sqdech.  */
   4434                                                               return 1778;
   4435                                                             }
   4436                                                           else
   4437                                                             {
   4438                                                               /* 33222222222211111111110000000000
   4439                                                                  10987654321098765432109876543210
   4440                                                                  xxxxxxxxxx01x011xxxxx1110x100000
   4441                                                                  sqdecd.  */
   4442                                                               return 1775;
   4443                                                             }
   4444                                                         }
   4445                                                     }
   4446                                                 }
   4447                                               else
   4448                                                 {
   4449                                                   if (((word >> 11) & 0x1) == 0)
   4450                                                     {
   4451                                                       if (((word >> 20) & 0x1) == 0)
   4452                                                         {
   4453                                                           if (((word >> 22) & 0x1) == 0)
   4454                                                             {
   4455                                                               /* 33222222222211111111110000000000
   4456                                                                  10987654321098765432109876543210
   4457                                                                  xxxxxxxxxx10x011xxxx010x0x100000
   4458                                                                  uqincw.  */
   4459                                                               return 1946;
   4460                                                             }
   4461                                                           else
   4462                                                             {
   4463                                                               if (((word >> 23) & 0x1) == 0)
   4464                                                                 {
   4465                                                                   /* 33222222222211111111110000000000
   4466                                                                      10987654321098765432109876543210
   4467                                                                      xxxxxxxxxx10x011xxxx01100x100000
   4468                                                                      uqinch.  */
   4469                                                                   return 1940;
   4470                                                                 }
   4471                                                               else
   4472                                                                 {
   4473                                                                   /* 33222222222211111111110000000000
   4474                                                                      10987654321098765432109876543210
   4475                                                                      xxxxxxxxxx10x011xxxx01110x100000
   4476                                                                      uqincd.  */
   4477                                                                   return 1937;
   4478                                                                 }
   4479                                                             }
   4480                                                         }
   4481                                                       else
   4482                                                         {
   4483                                                           if (((word >> 22) & 0x1) == 0)
   4484                                                             {
   4485                                                               /* 33222222222211111111110000000000
   4486                                                                  10987654321098765432109876543210
   4487                                                                  xxxxxxxxxx10x011xxxx110x0x100000
   4488                                                                  decw.  */
   4489                                                               return 1319;
   4490                                                             }
   4491                                                           else
   4492                                                             {
   4493                                                               if (((word >> 23) & 0x1) == 0)
   4494                                                                 {
   4495                                                                   /* 33222222222211111111110000000000
   4496                                                                      10987654321098765432109876543210
   4497                                                                      xxxxxxxxxx10x011xxxx11100x100000
   4498                                                                      dech.  */
   4499                                                                   return 1315;
   4500                                                                 }
   4501                                                               else
   4502                                                                 {
   4503                                                                   /* 33222222222211111111110000000000
   4504                                                                      10987654321098765432109876543210
   4505                                                                      xxxxxxxxxx10x011xxxx11110x100000
   4506                                                                      decd.  */
   4507                                                                   return 1313;
   4508                                                                 }
   4509                                                             }
   4510                                                         }
   4511                                                     }
   4512                                                   else
   4513                                                     {
   4514                                                       if (((word >> 22) & 0x1) == 0)
   4515                                                         {
   4516                                                           /* 33222222222211111111110000000000
   4517                                                              10987654321098765432109876543210
   4518                                                              xxxxxxxxxx11x011xxxxx10x0x100000
   4519                                                              uqdecw.  */
   4520                                                           return 1932;
   4521                                                         }
   4522                                                       else
   4523                                                         {
   4524                                                           if (((word >> 23) & 0x1) == 0)
   4525                                                             {
   4526                                                               /* 33222222222211111111110000000000
   4527                                                                  10987654321098765432109876543210
   4528                                                                  xxxxxxxxxx11x011xxxxx1100x100000
   4529                                                                  uqdech.  */
   4530                                                               return 1926;
   4531                                                             }
   4532                                                           else
   4533                                                             {
   4534                                                               /* 33222222222211111111110000000000
   4535                                                                  10987654321098765432109876543210
   4536                                                                  xxxxxxxxxx11x011xxxxx1110x100000
   4537                                                                  uqdecd.  */
   4538                                                               return 1923;
   4539                                                             }
   4540                                                         }
   4541                                                     }
   4542                                                 }
   4543                                             }
   4544                                         }
   4545                                       else
   4546                                         {
   4547                                           if (((word >> 22) & 0x1) == 0)
   4548                                             {
   4549                                               if (((word >> 21) & 0x1) == 0)
   4550                                                 {
   4551                                                   if (((word >> 23) & 0x1) == 0)
   4552                                                     {
   4553                                                       /* 33222222222211111111110000000000
   4554                                                          10987654321098765432109876543210
   4555                                                          xxxxxxxxxxxxx011xxxxx0000x100001
   4556                                                          prfb.  */
   4557                                                       return 1703;
   4558                                                     }
   4559                                                   else
   4560                                                     {
   4561                                                       /* 33222222222211111111110000000000
   4562                                                          10987654321098765432109876543210
   4563                                                          xxxxxxxxxxxxx011xxxxx0010x100001
   4564                                                          prfh.  */
   4565                                                       return 1718;
   4566                                                     }
   4567                                                 }
   4568                                               else
   4569                                                 {
   4570                                                   if (((word >> 23) & 0x1) == 0)
   4571                                                     {
   4572                                                       /* 33222222222211111111110000000000
   4573                                                          10987654321098765432109876543210
   4574                                                          xxxxxxxxxxxxx011xxxxx1000x100001
   4575                                                          ld1b.  */
   4576                                                       return 1463;
   4577                                                     }
   4578                                                   else
   4579                                                     {
   4580                                                       /* 33222222222211111111110000000000
   4581                                                          10987654321098765432109876543210
   4582                                                          xxxxxxxxxxxxx011xxxxx1010x100001
   4583                                                          ld1h.  */
   4584                                                       return 1485;
   4585                                                     }
   4586                                                 }
   4587                                             }
   4588                                           else
   4589                                             {
   4590                                               if (((word >> 23) & 0x1) == 0)
   4591                                                 {
   4592                                                   /* 33222222222211111111110000000000
   4593                                                      10987654321098765432109876543210
   4594                                                      xxxxxxxxxxxxx011xxxxxx100x100001
   4595                                                      ld1rb.  */
   4596                                                   return 1492;
   4597                                                 }
   4598                                               else
   4599                                                 {
   4600                                                   /* 33222222222211111111110000000000
   4601                                                      10987654321098765432109876543210
   4602                                                      xxxxxxxxxxxxx011xxxxxx110x100001
   4603                                                      ld1rh.  */
   4604                                                   return 1496;
   4605                                                 }
   4606                                             }
   4607                                         }
   4608                                     }
   4609                                   else
   4610                                     {
   4611                                       if (((word >> 21) & 0x1) == 0)
   4612                                         {
   4613                                           if (((word >> 23) & 0x1) == 0)
   4614                                             {
   4615                                               /* 33222222222211111111110000000000
   4616                                                  10987654321098765432109876543210
   4617                                                  xxxxxxxxxxxxx011xxxxx0x00x10001x
   4618                                                  ld1b.  */
   4619                                               return 1462;
   4620                                             }
   4621                                           else
   4622                                             {
   4623                                               /* 33222222222211111111110000000000
   4624                                                  10987654321098765432109876543210
   4625                                                  xxxxxxxxxxxxx011xxxxx0x10x10001x
   4626                                                  ld1h.  */
   4627                                               return 1483;
   4628                                             }
   4629                                         }
   4630                                       else
   4631                                         {
   4632                                           if (((word >> 22) & 0x1) == 0)
   4633                                             {
   4634                                               if (((word >> 23) & 0x1) == 0)
   4635                                                 {
   4636                                                   /* 33222222222211111111110000000000
   4637                                                      10987654321098765432109876543210
   4638                                                      xxxxxxxxxxxxx011xxxxx1000x10001x
   4639                                                      ld1b.  */
   4640                                                   return 1468;
   4641                                                 }
   4642                                               else
   4643                                                 {
   4644                                                   /* 33222222222211111111110000000000
   4645                                                      10987654321098765432109876543210
   4646                                                      xxxxxxxxxxxxx011xxxxx1010x10001x
   4647                                                      ld1h.  */
   4648                                                   return 1489;
   4649                                                 }
   4650                                             }
   4651                                           else
   4652                                             {
   4653                                               if (((word >> 23) & 0x1) == 0)
   4654                                                 {
   4655                                                   /* 33222222222211111111110000000000
   4656                                                      10987654321098765432109876543210
   4657                                                      xxxxxxxxxxxxx011xxxxx1100x10001x
   4658                                                      prfw.  */
   4659                                                   return 1727;
   4660                                                 }
   4661                                               else
   4662                                                 {
   4663                                                   /* 33222222222211111111110000000000
   4664                                                      10987654321098765432109876543210
   4665                                                      xxxxxxxxxxxxx011xxxxx1110x10001x
   4666                                                      ld1h.  */
   4667                                                   return 1484;
   4668                                                 }
   4669                                             }
   4670                                         }
   4671                                     }
   4672                                 }
   4673                             }
   4674                         }
   4675                       else
   4676                         {
   4677                           if (((word >> 14) & 0x1) == 0)
   4678                             {
   4679                               if (((word >> 15) & 0x1) == 0)
   4680                                 {
   4681                                   if (((word >> 21) & 0x1) == 0)
   4682                                     {
   4683                                       if (((word >> 30) & 0x1) == 0)
   4684                                         {
   4685                                           if (((word >> 31) & 0x1) == 0)
   4686                                             {
   4687                                               if (((word >> 17) & 0x1) == 0)
   4688                                                 {
   4689                                                   if (((word >> 19) & 0x1) == 0)
   4690                                                     {
   4691                                                       if (((word >> 20) & 0x1) == 0)
   4692                                                         {
   4693                                                           if (((word >> 16) & 0x1) == 0)
   4694                                                             {
   4695                                                               /* 33222222222211111111110000000000
   4696                                                                  10987654321098765432109876543210
   4697                                                                  xxxxxxxxxxxxx10000x000xx0x100000
   4698                                                                  saddv.  */
   4699                                                               return 1747;
   4700                                                             }
   4701                                                           else
   4702                                                             {
   4703                                                               /* 33222222222211111111110000000000
   4704                                                                  10987654321098765432109876543210
   4705                                                                  xxxxxxxxxxxxx10010x000xx0x100000
   4706                                                                  uaddv.  */
   4707                                                               return 1899;
   4708                                                             }
   4709                                                         }
   4710                                                       else
   4711                                                         {
   4712                                                           /* 33222222222211111111110000000000
   4713                                                              10987654321098765432109876543210
   4714                                                              xxxxxxxxxxxxx100x0x010xx0x100000
   4715                                                              movprfx.  */
   4716                                                           return 1682;
   4717                                                         }
   4718                                                     }
   4719                                                   else
   4720                                                     {
   4721                                                       if (((word >> 16) & 0x1) == 0)
   4722                                                         {
   4723                                                           if (((word >> 20) & 0x1) == 0)
   4724                                                             {
   4725                                                               /* 33222222222211111111110000000000
   4726                                                                  10987654321098765432109876543210
   4727                                                                  xxxxxxxxxxxxx10000x100xx0x100000
   4728                                                                  smaxv.  */
   4729                                                               return 1765;
   4730                                                             }
   4731                                                           else
   4732                                                             {
   4733                                                               /* 33222222222211111111110000000000
   4734                                                                  10987654321098765432109876543210
   4735                                                                  xxxxxxxxxxxxx10000x110xx0x100000
   4736                                                                  orv.  */
   4737                                                               return 1699;
   4738                                                             }
   4739                                                         }
   4740                                                       else
   4741                                                         {
   4742                                                           if (((word >> 20) & 0x1) == 0)
   4743                                                             {
   4744                                                               /* 33222222222211111111110000000000
   4745                                                                  10987654321098765432109876543210
   4746                                                                  xxxxxxxxxxxxx10010x100xx0x100000
   4747                                                                  umaxv.  */
   4748                                                               return 1914;
   4749                                                             }
   4750                                                           else
   4751                                                             {
   4752                                                               /* 33222222222211111111110000000000
   4753                                                                  10987654321098765432109876543210
   4754                                                                  xxxxxxxxxxxxx10010x110xx0x100000
   4755                                                                  eorv.  */
   4756                                                               return 1330;
   4757                                                             }
   4758                                                         }
   4759                                                     }
   4760                                                 }
   4761                                               else
   4762                                                 {
   4763                                                   if (((word >> 16) & 0x1) == 0)
   4764                                                     {
   4765                                                       if (((word >> 20) & 0x1) == 0)
   4766                                                         {
   4767                                                           /* 33222222222211111111110000000000
   4768                                                              10987654321098765432109876543210
   4769                                                              xxxxxxxxxxxxx10001xx00xx0x100000
   4770                                                              sminv.  */
   4771                                                           return 1768;
   4772                                                         }
   4773                                                       else
   4774                                                         {
   4775                                                           /* 33222222222211111111110000000000
   4776                                                              10987654321098765432109876543210
   4777                                                              xxxxxxxxxxxxx10001xx10xx0x100000
   4778                                                              andv.  */
   4779                                                           return 1243;
   4780                                                         }
   4781                                                     }
   4782                                                   else
   4783                                                     {
   4784                                                       /* 33222222222211111111110000000000
   4785                                                          10987654321098765432109876543210
   4786                                                          xxxxxxxxxxxxx10011xxx0xx0x100000
   4787                                                          uminv.  */
   4788                                                       return 1917;
   4789                                                     }
   4790                                                 }
   4791                                             }
   4792                                           else
   4793                                             {
   4794                                               if (((word >> 23) & 0x1) == 0)
   4795                                                 {
   4796                                                   /* 33222222222211111111110000000000
   4797                                                      10987654321098765432109876543210
   4798                                                      xxxxxxxxxxxxx100xxxxx0x00x100001
   4799                                                      ldff1sb.  */
   4800                                                   return 1606;
   4801                                                 }
   4802                                               else
   4803                                                 {
   4804                                                   /* 33222222222211111111110000000000
   4805                                                      10987654321098765432109876543210
   4806                                                      xxxxxxxxxxxxx100xxxxx0x10x100001
   4807                                                      ldff1sh.  */
   4808                                                   return 1614;
   4809                                                 }
   4810                                             }
   4811                                         }
   4812                                       else
   4813                                         {
   4814                                           if (((word >> 23) & 0x1) == 0)
   4815                                             {
   4816                                               /* 33222222222211111111110000000000
   4817                                                  10987654321098765432109876543210
   4818                                                  xxxxxxxxxxxxx100xxxxx0x00x10001x
   4819                                                  ldff1sb.  */
   4820                                               return 1610;
   4821                                             }
   4822                                           else
   4823                                             {
   4824                                               /* 33222222222211111111110000000000
   4825                                                  10987654321098765432109876543210
   4826                                                  xxxxxxxxxxxxx100xxxxx0x10x10001x
   4827                                                  ldff1sh.  */
   4828                                               return 1618;
   4829                                             }
   4830                                         }
   4831                                     }
   4832                                   else
   4833                                     {
   4834                                       if (((word >> 23) & 0x1) == 0)
   4835                                         {
   4836                                           if (((word >> 30) & 0x1) == 0)
   4837                                             {
   4838                                               if (((word >> 31) & 0x1) == 0)
   4839                                                 {
   4840                                                   if (((word >> 22) & 0x1) == 0)
   4841                                                     {
   4842                                                       /* 33222222222211111111110000000000
   4843                                                          10987654321098765432109876543210
   4844                                                          xxxxxxxxxxxxx100xxxxx1000x100000
   4845                                                          and.  */
   4846                                                       return 1238;
   4847                                                     }
   4848                                                   else
   4849                                                     {
   4850                                                       /* 33222222222211111111110000000000
   4851                                                          10987654321098765432109876543210
   4852                                                          xxxxxxxxxxxxx100xxxxx1100x100000
   4853                                                          orr.  */
   4854                                                       return 1694;
   4855                                                     }
   4856                                                 }
   4857                                               else
   4858                                                 {
   4859                                                   /* 33222222222211111111110000000000
   4860                                                      10987654321098765432109876543210
   4861                                                      xxxxxxxxxxxxx100xxxxx1x00x100001
   4862                                                      prfh.  */
   4863                                                   return 1717;
   4864                                                 }
   4865                                             }
   4866                                           else
   4867                                             {
   4868                                               /* 33222222222211111111110000000000
   4869                                                  10987654321098765432109876543210
   4870                                                  xxxxxxxxxxxxx100xxxxx1x00x10001x
   4871                                                  prfh.  */
   4872                                               return 1719;
   4873                                             }
   4874                                         }
   4875                                       else
   4876                                         {
   4877                                           if (((word >> 30) & 0x1) == 0)
   4878                                             {
   4879                                               if (((word >> 31) & 0x1) == 0)
   4880                                                 {
   4881                                                   if (((word >> 22) & 0x1) == 0)
   4882                                                     {
   4883                                                       /* 33222222222211111111110000000000
   4884                                                          10987654321098765432109876543210
   4885                                                          xxxxxxxxxxxxx100xxxxx1010x100000
   4886                                                          eor.  */
   4887                                                       return 1325;
   4888                                                     }
   4889                                                   else
   4890                                                     {
   4891                                                       /* 33222222222211111111110000000000
   4892                                                          10987654321098765432109876543210
   4893                                                          xxxxxxxxxxxxx100xxxxx1110x100000
   4894                                                          bic.  */
   4895                                                       return 1251;
   4896                                                     }
   4897                                                 }
   4898                                               else
   4899                                                 {
   4900                                                   /* 33222222222211111111110000000000
   4901                                                      10987654321098765432109876543210
   4902                                                      xxxxxxxxxxxxx100xxxxx1x10x100001
   4903                                                      ldff1sh.  */
   4904                                                   return 1615;
   4905                                                 }
   4906                                             }
   4907                                           else
   4908                                             {
   4909                                               /* 33222222222211111111110000000000
   4910                                                  10987654321098765432109876543210
   4911                                                  xxxxxxxxxxxxx100xxxxx1x10x10001x
   4912                                                  ldff1sh.  */
   4913                                               return 1619;
   4914                                             }
   4915                                         }
   4916                                     }
   4917                                 }
   4918                               else
   4919                                 {
   4920                                   if (((word >> 30) & 0x1) == 0)
   4921                                     {
   4922                                       if (((word >> 31) & 0x1) == 0)
   4923                                         {
   4924                                           if (((word >> 21) & 0x1) == 0)
   4925                                             {
   4926                                               if (((word >> 16) & 0x1) == 0)
   4927                                                 {
   4928                                                   if (((word >> 17) & 0x1) == 0)
   4929                                                     {
   4930                                                       if (((word >> 18) & 0x1) == 0)
   4931                                                         {
   4932                                                           if (((word >> 19) & 0x1) == 0)
   4933                                                             {
   4934                                                               /* 33222222222211111111110000000000
   4935                                                                  10987654321098765432109876543210
   4936                                                                  xxxxxxxxxxxxx1010000x0xx0x100000
   4937                                                                  sxtb.  */
   4938                                                               return 1890;
   4939                                                             }
   4940                                                           else
   4941                                                             {
   4942                                                               /* 33222222222211111111110000000000
   4943                                                                  10987654321098765432109876543210
   4944                                                                  xxxxxxxxxxxxx1010001x0xx0x100000
   4945                                                                  cls.  */
   4946                                                               return 1271;
   4947                                                             }
   4948                                                         }
   4949                                                       else
   4950                                                         {
   4951                                                           if (((word >> 19) & 0x1) == 0)
   4952                                                             {
   4953                                                               /* 33222222222211111111110000000000
   4954                                                                  10987654321098765432109876543210
   4955                                                                  xxxxxxxxxxxxx1010010x0xx0x100000
   4956                                                                  sxtw.  */
   4957                                                               return 1892;
   4958                                                             }
   4959                                                           else
   4960                                                             {
   4961                                                               /* 33222222222211111111110000000000
   4962                                                                  10987654321098765432109876543210
   4963                                                                  xxxxxxxxxxxxx1010011x0xx0x100000
   4964                                                                  fabs.  */
   4965                                                               return 1333;
   4966                                                             }
   4967                                                         }
   4968                                                     }
   4969                                                   else
   4970                                                     {
   4971                                                       if (((word >> 18) & 0x1) == 0)
   4972                                                         {
   4973                                                           if (((word >> 19) & 0x1) == 0)
   4974                                                             {
   4975                                                               /* 33222222222211111111110000000000
   4976                                                                  10987654321098765432109876543210
   4977                                                                  xxxxxxxxxxxxx1010100x0xx0x100000
   4978                                                                  sxth.  */
   4979                                                               return 1891;
   4980                                                             }
   4981                                                           else
   4982                                                             {
   4983                                                               /* 33222222222211111111110000000000
   4984                                                                  10987654321098765432109876543210
   4985                                                                  xxxxxxxxxxxxx1010101x0xx0x100000
   4986                                                                  cnt.  */
   4987                                                               return 1300;
   4988                                                             }
   4989                                                         }
   4990                                                       else
   4991                                                         {
   4992                                                           if (((word >> 19) & 0x1) == 0)
   4993                                                             {
   4994                                                               /* 33222222222211111111110000000000
   4995                                                                  10987654321098765432109876543210
   4996                                                                  xxxxxxxxxxxxx1010110x0xx0x100000
   4997                                                                  abs.  */
   4998                                                               return 1229;
   4999                                                             }
   5000                                                           else
   5001                                                             {
   5002                                                               /* 33222222222211111111110000000000
   5003                                                                  10987654321098765432109876543210
   5004                                                                  xxxxxxxxxxxxx1010111x0xx0x100000
   5005                                                                  not.  */
   5006                                                               return 1691;
   5007                                                             }
   5008                                                         }
   5009                                                     }
   5010                                                 }
   5011                                               else
   5012                                                 {
   5013                                                   if (((word >> 17) & 0x1) == 0)
   5014                                                     {
   5015                                                       if (((word >> 18) & 0x1) == 0)
   5016                                                         {
   5017                                                           if (((word >> 19) & 0x1) == 0)
   5018                                                             {
   5019                                                               /* 33222222222211111111110000000000
   5020                                                                  10987654321098765432109876543210
   5021                                                                  xxxxxxxxxxxxx1011000x0xx0x100000
   5022                                                                  uxtb.  */
   5023                                                               return 1953;
   5024                                                             }
   5025                                                           else
   5026                                                             {
   5027                                                               /* 33222222222211111111110000000000
   5028                                                                  10987654321098765432109876543210
   5029                                                                  xxxxxxxxxxxxx1011001x0xx0x100000
   5030                                                                  clz.  */
   5031                                                               return 1272;
   5032                                                             }
   5033                                                         }
   5034                                                       else
   5035                                                         {
   5036                                                           if (((word >> 19) & 0x1) == 0)
   5037                                                             {
   5038                                                               /* 33222222222211111111110000000000
   5039                                                                  10987654321098765432109876543210
   5040                                                                  xxxxxxxxxxxxx1011010x0xx0x100000
   5041                                                                  uxtw.  */
   5042                                                               return 1955;
   5043                                                             }
   5044                                                           else
   5045                                                             {
   5046                                                               /* 33222222222211111111110000000000
   5047                                                                  10987654321098765432109876543210
   5048                                                                  xxxxxxxxxxxxx1011011x0xx0x100000
   5049                                                                  fneg.  */
   5050                                                               return 1410;
   5051                                                             }
   5052                                                         }
   5053                                                     }
   5054                                                   else
   5055                                                     {
   5056                                                       if (((word >> 18) & 0x1) == 0)
   5057                                                         {
   5058                                                           if (((word >> 19) & 0x1) == 0)
   5059                                                             {
   5060                                                               /* 33222222222211111111110000000000
   5061                                                                  10987654321098765432109876543210
   5062                                                                  xxxxxxxxxxxxx1011100x0xx0x100000
   5063                                                                  uxth.  */
   5064                                                               return 1954;
   5065                                                             }
   5066                                                           else
   5067                                                             {
   5068                                                               /* 33222222222211111111110000000000
   5069                                                                  10987654321098765432109876543210
   5070                                                                  xxxxxxxxxxxxx1011101x0xx0x100000
   5071                                                                  cnot.  */
   5072                                                               return 1299;
   5073                                                             }
   5074                                                         }
   5075                                                       else
   5076                                                         {
   5077                                                           /* 33222222222211111111110000000000
   5078                                                              10987654321098765432109876543210
   5079                                                              xxxxxxxxxxxxx101111xx0xx0x100000
   5080                                                              neg.  */
   5081                                                           return 1688;
   5082                                                         }
   5083                                                     }
   5084                                                 }
   5085                                             }
   5086                                           else
   5087                                             {
   5088                                               if (((word >> 12) & 0x1) == 0)
   5089                                                 {
   5090                                                   if (((word >> 23) & 0x1) == 0)
   5091                                                     {
   5092                                                       if (((word >> 22) & 0x1) == 0)
   5093                                                         {
   5094                                                           /* 33222222222211111111110000000000
   5095                                                              10987654321098765432109876543210
   5096                                                              xxxxxxxxxxxx0101xxxxx1000x100000
   5097                                                              adr.  */
   5098                                                           return 1235;
   5099                                                         }
   5100                                                       else
   5101                                                         {
   5102                                                           /* 33222222222211111111110000000000
   5103                                                              10987654321098765432109876543210
   5104                                                              xxxxxxxxxxxx0101xxxxx1100x100000
   5105                                                              adr.  */
   5106                                                           return 1236;
   5107                                                         }
   5108                                                     }
   5109                                                   else
   5110                                                     {
   5111                                                       /* 33222222222211111111110000000000
   5112                                                          10987654321098765432109876543210
   5113                                                          xxxxxxxxxxxx0101xxxxx1x10x100000
   5114                                                          adr.  */
   5115                                                       return 1237;
   5116                                                     }
   5117                                                 }
   5118                                               else
   5119                                                 {
   5120                                                   if (((word >> 10) & 0x1) == 0)
   5121                                                     {
   5122                                                       if (((word >> 11) & 0x1) == 0)
   5123                                                         {
   5124                                                           /* 33222222222211111111110000000000
   5125                                                              10987654321098765432109876543210
   5126                                                              xxxxxxxxxx001101xxxxx1xx0x100000
   5127                                                              ftssel.  */
   5128                                                           return 1436;
   5129                                                         }
   5130                                                       else
   5131                                                         {
   5132                                                           /* 33222222222211111111110000000000
   5133                                                              10987654321098765432109876543210
   5134                                                              xxxxxxxxxx011101xxxxx1xx0x100000
   5135                                                              fexpa.  */
   5136                                                           return 1380;
   5137                                                         }
   5138                                                     }
   5139                                                   else
   5140                                                     {
   5141                                                       /* 33222222222211111111110000000000
   5142                                                          10987654321098765432109876543210
   5143                                                          xxxxxxxxxx1x1101xxxxx1xx0x100000
   5144                                                          movprfx.  */
   5145                                                       return 1681;
   5146                                                     }
   5147                                                 }
   5148                                             }
   5149                                         }
   5150                                       else
   5151                                         {
   5152                                           if (((word >> 22) & 0x1) == 0)
   5153                                             {
   5154                                               if (((word >> 23) & 0x1) == 0)
   5155                                                 {
   5156                                                   /* 33222222222211111111110000000000
   5157                                                      10987654321098765432109876543210
   5158                                                      xxxxxxxxxxxxx101xxxxxx000x100001
   5159                                                      ldff1sb.  */
   5160                                                   return 1612;
   5161                                                 }
   5162                                               else
   5163                                                 {
   5164                                                   /* 33222222222211111111110000000000
   5165                                                      10987654321098765432109876543210
   5166                                                      xxxxxxxxxxxxx101xxxxxx010x100001
   5167                                                      ldff1sh.  */
   5168                                                   return 1622;
   5169                                                 }
   5170                                             }
   5171                                           else
   5172                                             {
   5173                                               if (((word >> 23) & 0x1) == 0)
   5174                                                 {
   5175                                                   /* 33222222222211111111110000000000
   5176                                                      10987654321098765432109876543210
   5177                                                      xxxxxxxxxxxxx101xxxxxx100x100001
   5178                                                      ld1rb.  */
   5179                                                   return 1491;
   5180                                                 }
   5181                                               else
   5182                                                 {
   5183                                                   /* 33222222222211111111110000000000
   5184                                                      10987654321098765432109876543210
   5185                                                      xxxxxxxxxxxxx101xxxxxx110x100001
   5186                                                      ld1rh.  */
   5187                                                   return 1495;
   5188                                                 }
   5189                                             }
   5190                                         }
   5191                                     }
   5192                                   else
   5193                                     {
   5194                                       if (((word >> 21) & 0x1) == 0)
   5195                                         {
   5196                                           if (((word >> 23) & 0x1) == 0)
   5197                                             {
   5198                                               /* 33222222222211111111110000000000
   5199                                                  10987654321098765432109876543210
   5200                                                  xxxxxxxxxxxxx101xxxxx0x00x10001x
   5201                                                  ldff1sb.  */
   5202                                               return 1611;
   5203                                             }
   5204                                           else
   5205                                             {
   5206                                               /* 33222222222211111111110000000000
   5207                                                  10987654321098765432109876543210
   5208                                                  xxxxxxxxxxxxx101xxxxx0x10x10001x
   5209                                                  ldff1sh.  */
   5210                                               return 1620;
   5211                                             }
   5212                                         }
   5213                                       else
   5214                                         {
   5215                                           if (((word >> 22) & 0x1) == 0)
   5216                                             {
   5217                                               if (((word >> 23) & 0x1) == 0)
   5218                                                 {
   5219                                                   /* 33222222222211111111110000000000
   5220                                                      10987654321098765432109876543210
   5221                                                      xxxxxxxxxxxxx101xxxxx1000x10001x
   5222                                                      ldff1sb.  */
   5223                                                   return 1613;
   5224                                                 }
   5225                                               else
   5226                                                 {
   5227                                                   /* 33222222222211111111110000000000
   5228                                                      10987654321098765432109876543210
   5229                                                      xxxxxxxxxxxxx101xxxxx1010x10001x
   5230                                                      ldff1sh.  */
   5231                                                   return 1623;
   5232                                                 }
   5233                                             }
   5234                                           else
   5235                                             {
   5236                                               if (((word >> 23) & 0x1) == 0)
   5237                                                 {
   5238                                                   /* 33222222222211111111110000000000
   5239                                                      10987654321098765432109876543210
   5240                                                      xxxxxxxxxxxxx101xxxxx1100x10001x
   5241                                                      prfh.  */
   5242                                                   return 1720;
   5243                                                 }
   5244                                               else
   5245                                                 {
   5246                                                   /* 33222222222211111111110000000000
   5247                                                      10987654321098765432109876543210
   5248                                                      xxxxxxxxxxxxx101xxxxx1110x10001x
   5249                                                      ldff1sh.  */
   5250                                                   return 1621;
   5251                                                 }
   5252                                             }
   5253                                         }
   5254                                     }
   5255                                 }
   5256                             }
   5257                           else
   5258                             {
   5259                               if (((word >> 15) & 0x1) == 0)
   5260                                 {
   5261                                   if (((word >> 21) & 0x1) == 0)
   5262                                     {
   5263                                       if (((word >> 30) & 0x1) == 0)
   5264                                         {
   5265                                           if (((word >> 31) & 0x1) == 0)
   5266                                             {
   5267                                               /* 33222222222211111111110000000000
   5268                                                  10987654321098765432109876543210
   5269                                                  xxxxxxxxxxxxx110xxxxx0xx0x100000
   5270                                                  mls.  */
   5271                                               return 1680;
   5272                                             }
   5273                                           else
   5274                                             {
   5275                                               if (((word >> 23) & 0x1) == 0)
   5276                                                 {
   5277                                                   /* 33222222222211111111110000000000
   5278                                                      10987654321098765432109876543210
   5279                                                      xxxxxxxxxxxxx110xxxxx0x00x100001
   5280                                                      ldff1b.  */
   5281                                                   return 1580;
   5282                                                 }
   5283                                               else
   5284                                                 {
   5285                                                   /* 33222222222211111111110000000000
   5286                                                      10987654321098765432109876543210
   5287                                                      xxxxxxxxxxxxx110xxxxx0x10x100001
   5288                                                      ldff1h.  */
   5289                                                   return 1595;
   5290                                                 }
   5291                                             }
   5292                                         }
   5293                                       else
   5294                                         {
   5295                                           if (((word >> 23) & 0x1) == 0)
   5296                                             {
   5297                                               /* 33222222222211111111110000000000
   5298                                                  10987654321098765432109876543210
   5299                                                  xxxxxxxxxxxxx110xxxxx0x00x10001x
   5300                                                  ldff1b.  */
   5301                                               return 1585;
   5302                                             }
   5303                                           else
   5304                                             {
   5305                                               /* 33222222222211111111110000000000
   5306                                                  10987654321098765432109876543210
   5307                                                  xxxxxxxxxxxxx110xxxxx0x10x10001x
   5308                                                  ldff1h.  */
   5309                                               return 1600;
   5310                                             }
   5311                                         }
   5312                                     }
   5313                                   else
   5314                                     {
   5315                                       if (((word >> 23) & 0x1) == 0)
   5316                                         {
   5317                                           if (((word >> 30) & 0x1) == 0)
   5318                                             {
   5319                                               /* 33222222222211111111110000000000
   5320                                                  10987654321098765432109876543210
   5321                                                  xxxxxxxxxxxxx110xxxxx1x00x10000x
   5322                                                  prfd.  */
   5323                                               return 1710;
   5324                                             }
   5325                                           else
   5326                                             {
   5327                                               /* 33222222222211111111110000000000
   5328                                                  10987654321098765432109876543210
   5329                                                  xxxxxxxxxxxxx110xxxxx1x00x10001x
   5330                                                  prfd.  */
   5331                                               return 1712;
   5332                                             }
   5333                                         }
   5334                                       else
   5335                                         {
   5336                                           if (((word >> 30) & 0x1) == 0)
   5337                                             {
   5338                                               /* 33222222222211111111110000000000
   5339                                                  10987654321098765432109876543210
   5340                                                  xxxxxxxxxxxxx110xxxxx1x10x10000x
   5341                                                  ldff1h.  */
   5342                                               return 1596;
   5343                                             }
   5344                                           else
   5345                                             {
   5346                                               /* 33222222222211111111110000000000
   5347                                                  10987654321098765432109876543210
   5348                                                  xxxxxxxxxxxxx110xxxxx1x10x10001x
   5349                                                  ldff1h.  */
   5350                                               return 1601;
   5351                                             }
   5352                                         }
   5353                                     }
   5354                                 }
   5355                               else
   5356                                 {
   5357                                   if (((word >> 30) & 0x1) == 0)
   5358                                     {
   5359                                       if (((word >> 31) & 0x1) == 0)
   5360                                         {
   5361                                           if (((word >> 21) & 0x1) == 0)
   5362                                             {
   5363                                               /* 33222222222211111111110000000000
   5364                                                  10987654321098765432109876543210
   5365                                                  xxxxxxxxxxxxx111xxxxx0xx0x100000
   5366                                                  msb.  */
   5367                                               return 1683;
   5368                                             }
   5369                                           else
   5370                                             {
   5371                                               if (((word >> 10) & 0x1) == 0)
   5372                                                 {
   5373                                                   if (((word >> 11) & 0x1) == 0)
   5374                                                     {
   5375                                                       if (((word >> 12) & 0x1) == 0)
   5376                                                         {
   5377                                                           if (((word >> 20) & 0x1) == 0)
   5378                                                             {
   5379                                                               if (((word >> 22) & 0x1) == 0)
   5380                                                                 {
   5381                                                                   if (((word >> 23) & 0x1) == 0)
   5382                                                                     {
   5383                                                                       /* 33222222222211111111110000000000
   5384                                                                          10987654321098765432109876543210
   5385                                                                          xxxxxxxxxx000111xxxx01000x100000
   5386                                                                          cntb.  */
   5387                                                                       return 1301;
   5388                                                                     }
   5389                                                                   else
   5390                                                                     {
   5391                                                                       /* 33222222222211111111110000000000
   5392                                                                          10987654321098765432109876543210
   5393                                                                          xxxxxxxxxx000111xxxx01010x100000
   5394                                                                          cntw.  */
   5395                                                                       return 1305;
   5396                                                                     }
   5397                                                                 }
   5398                                                               else
   5399                                                                 {
   5400                                                                   if (((word >> 23) & 0x1) == 0)
   5401                                                                     {
   5402                                                                       /* 33222222222211111111110000000000
   5403                                                                          10987654321098765432109876543210
   5404                                                                          xxxxxxxxxx000111xxxx01100x100000
   5405                                                                          cnth.  */
   5406                                                                       return 1303;
   5407                                                                     }
   5408                                                                   else
   5409                                                                     {
   5410                                                                       /* 33222222222211111111110000000000
   5411                                                                          10987654321098765432109876543210
   5412                                                                          xxxxxxxxxx000111xxxx01110x100000
   5413                                                                          cntd.  */
   5414                                                                       return 1302;
   5415                                                                     }
   5416                                                                 }
   5417                                                             }
   5418                                                           else
   5419                                                             {
   5420                                                               if (((word >> 22) & 0x1) == 0)
   5421                                                                 {
   5422                                                                   if (((word >> 23) & 0x1) == 0)
   5423                                                                     {
   5424                                                                       /* 33222222222211111111110000000000
   5425                                                                          10987654321098765432109876543210
   5426                                                                          xxxxxxxxxx000111xxxx11000x100000
   5427                                                                          incb.  */
   5428                                                                       return 1437;
   5429                                                                     }
   5430                                                                   else
   5431                                                                     {
   5432                                                                       /* 33222222222211111111110000000000
   5433                                                                          10987654321098765432109876543210
   5434                                                                          xxxxxxxxxx000111xxxx11010x100000
   5435                                                                          incw.  */
   5436                                                                       return 1445;
   5437                                                                     }
   5438                                                                 }
   5439                                                               else
   5440                                                                 {
   5441                                                                   if (((word >> 23) & 0x1) == 0)
   5442                                                                     {
   5443                                                                       /* 33222222222211111111110000000000
   5444                                                                          10987654321098765432109876543210
   5445                                                                          xxxxxxxxxx000111xxxx11100x100000
   5446                                                                          inch.  */
   5447                                                                       return 1441;
   5448                                                                     }
   5449                                                                   else
   5450                                                                     {
   5451                                                                       /* 33222222222211111111110000000000
   5452                                                                          10987654321098765432109876543210
   5453                                                                          xxxxxxxxxx000111xxxx11110x100000
   5454                                                                          incd.  */
   5455                                                                       return 1439;
   5456                                                                     }
   5457                                                                 }
   5458                                                             }
   5459                                                         }
   5460                                                       else
   5461                                                         {
   5462                                                           if (((word >> 20) & 0x1) == 0)
   5463                                                             {
   5464                                                               if (((word >> 22) & 0x1) == 0)
   5465                                                                 {
   5466                                                                   if (((word >> 23) & 0x1) == 0)
   5467                                                                     {
   5468                                                                       /* 33222222222211111111110000000000
   5469                                                                          10987654321098765432109876543210
   5470                                                                          xxxxxxxxxx001111xxxx01000x100000
   5471                                                                          sqincb.  */
   5472                                                                       return 1788;
   5473                                                                     }
   5474                                                                   else
   5475                                                                     {
   5476                                                                       /* 33222222222211111111110000000000
   5477                                                                          10987654321098765432109876543210
   5478                                                                          xxxxxxxxxx001111xxxx01010x100000
   5479                                                                          sqincw.  */
   5480                                                                       return 1800;
   5481                                                                     }
   5482                                                                 }
   5483                                                               else
   5484                                                                 {
   5485                                                                   if (((word >> 23) & 0x1) == 0)
   5486                                                                     {
   5487                                                                       /* 33222222222211111111110000000000
   5488                                                                          10987654321098765432109876543210
   5489                                                                          xxxxxxxxxx001111xxxx01100x100000
   5490                                                                          sqinch.  */
   5491                                                                       return 1794;
   5492                                                                     }
   5493                                                                   else
   5494                                                                     {
   5495                                                                       /* 33222222222211111111110000000000
   5496                                                                          10987654321098765432109876543210
   5497                                                                          xxxxxxxxxx001111xxxx01110x100000
   5498                                                                          sqincd.  */
   5499                                                                       return 1791;
   5500                                                                     }
   5501                                                                 }
   5502                                                             }
   5503                                                           else
   5504                                                             {
   5505                                                               if (((word >> 22) & 0x1) == 0)
   5506                                                                 {
   5507                                                                   if (((word >> 23) & 0x1) == 0)
   5508                                                                     {
   5509                                                                       /* 33222222222211111111110000000000
   5510                                                                          10987654321098765432109876543210
   5511                                                                          xxxxxxxxxx001111xxxx11000x100000
   5512                                                                          sqincb.  */
   5513                                                                       return 1787;
   5514                                                                     }
   5515                                                                   else
   5516                                                                     {
   5517                                                                       /* 33222222222211111111110000000000
   5518                                                                          10987654321098765432109876543210
   5519                                                                          xxxxxxxxxx001111xxxx11010x100000
   5520                                                                          sqincw.  */
   5521                                                                       return 1799;
   5522                                                                     }
   5523                                                                 }
   5524                                                               else
   5525                                                                 {
   5526                                                                   if (((word >> 23) & 0x1) == 0)
   5527                                                                     {
   5528                                                                       /* 33222222222211111111110000000000
   5529                                                                          10987654321098765432109876543210
   5530                                                                          xxxxxxxxxx001111xxxx11100x100000
   5531                                                                          sqinch.  */
   5532                                                                       return 1793;
   5533                                                                     }
   5534                                                                   else
   5535                                                                     {
   5536                                                                       /* 33222222222211111111110000000000
   5537                                                                          10987654321098765432109876543210
   5538                                                                          xxxxxxxxxx001111xxxx11110x100000
   5539                                                                          sqincd.  */
   5540                                                                       return 1790;
   5541                                                                     }
   5542                                                                 }
   5543                                                             }
   5544                                                         }
   5545                                                     }
   5546                                                   else
   5547                                                     {
   5548                                                       if (((word >> 20) & 0x1) == 0)
   5549                                                         {
   5550                                                           if (((word >> 22) & 0x1) == 0)
   5551                                                             {
   5552                                                               if (((word >> 23) & 0x1) == 0)
   5553                                                                 {
   5554                                                                   /* 33222222222211111111110000000000
   5555                                                                      10987654321098765432109876543210
   5556                                                                      xxxxxxxxxx01x111xxxx01000x100000
   5557                                                                      sqdecb.  */
   5558                                                                   return 1774;
   5559                                                                 }
   5560                                                               else
   5561                                                                 {
   5562                                                                   /* 33222222222211111111110000000000
   5563                                                                      10987654321098765432109876543210
   5564                                                                      xxxxxxxxxx01x111xxxx01010x100000
   5565                                                                      sqdecw.  */
   5566                                                                   return 1786;
   5567                                                                 }
   5568                                                             }
   5569                                                           else
   5570                                                             {
   5571                                                               if (((word >> 23) & 0x1) == 0)
   5572                                                                 {
   5573                                                                   /* 33222222222211111111110000000000
   5574                                                                      10987654321098765432109876543210
   5575                                                                      xxxxxxxxxx01x111xxxx01100x100000
   5576                                                                      sqdech.  */
   5577                                                                   return 1780;
   5578                                                                 }
   5579                                                               else
   5580                                                                 {
   5581                                                                   /* 33222222222211111111110000000000
   5582                                                                      10987654321098765432109876543210
   5583                                                                      xxxxxxxxxx01x111xxxx01110x100000
   5584                                                                      sqdecd.  */
   5585                                                                   return 1777;
   5586                                                                 }
   5587                                                             }
   5588                                                         }
   5589                                                       else
   5590                                                         {
   5591                                                           if (((word >> 22) & 0x1) == 0)
   5592                                                             {
   5593                                                               if (((word >> 23) & 0x1) == 0)
   5594                                                                 {
   5595                                                                   /* 33222222222211111111110000000000
   5596                                                                      10987654321098765432109876543210
   5597                                                                      xxxxxxxxxx01x111xxxx11000x100000
   5598                                                                      sqdecb.  */
   5599                                                                   return 1773;
   5600                                                                 }
   5601                                                               else
   5602                                                                 {
   5603                                                                   /* 33222222222211111111110000000000
   5604                                                                      10987654321098765432109876543210
   5605                                                                      xxxxxxxxxx01x111xxxx11010x100000
   5606                                                                      sqdecw.  */
   5607                                                                   return 1785;
   5608                                                                 }
   5609                                                             }
   5610                                                           else
   5611                                                             {
   5612                                                               if (((word >> 23) & 0x1) == 0)
   5613                                                                 {
   5614                                                                   /* 33222222222211111111110000000000
   5615                                                                      10987654321098765432109876543210
   5616                                                                      xxxxxxxxxx01x111xxxx11100x100000
   5617                                                                      sqdech.  */
   5618                                                                   return 1779;
   5619                                                                 }
   5620                                                               else
   5621                                                                 {
   5622                                                                   /* 33222222222211111111110000000000
   5623                                                                      10987654321098765432109876543210
   5624                                                                      xxxxxxxxxx01x111xxxx11110x100000
   5625                                                                      sqdecd.  */
   5626                                                                   return 1776;
   5627                                                                 }
   5628                                                             }
   5629                                                         }
   5630                                                     }
   5631                                                 }
   5632                                               else
   5633                                                 {
   5634                                                   if (((word >> 11) & 0x1) == 0)
   5635                                                     {
   5636                                                       if (((word >> 12) & 0x1) == 0)
   5637                                                         {
   5638                                                           if (((word >> 22) & 0x1) == 0)
   5639                                                             {
   5640                                                               if (((word >> 23) & 0x1) == 0)
   5641                                                                 {
   5642                                                                   /* 33222222222211111111110000000000
   5643                                                                      10987654321098765432109876543210
   5644                                                                      xxxxxxxxxx100111xxxxx1000x100000
   5645                                                                      decb.  */
   5646                                                                   return 1312;
   5647                                                                 }
   5648                                                               else
   5649                                                                 {
   5650                                                                   /* 33222222222211111111110000000000
   5651                                                                      10987654321098765432109876543210
   5652                                                                      xxxxxxxxxx100111xxxxx1010x100000
   5653                                                                      decw.  */
   5654                                                                   return 1320;
   5655                                                                 }
   5656                                                             }
   5657                                                           else
   5658                                                             {
   5659                                                               if (((word >> 23) & 0x1) == 0)
   5660                                                                 {
   5661                                                                   /* 33222222222211111111110000000000
   5662                                                                      10987654321098765432109876543210
   5663                                                                      xxxxxxxxxx100111xxxxx1100x100000
   5664                                                                      dech.  */
   5665                                                                   return 1316;
   5666                                                                 }
   5667                                                               else
   5668                                                                 {
   5669                                                                   /* 33222222222211111111110000000000
   5670                                                                      10987654321098765432109876543210
   5671                                                                      xxxxxxxxxx100111xxxxx1110x100000
   5672                                                                      decd.  */
   5673                                                                   return 1314;
   5674                                                                 }
   5675                                                             }
   5676                                                         }
   5677                                                       else
   5678                                                         {
   5679                                                           if (((word >> 20) & 0x1) == 0)
   5680                                                             {
   5681                                                               if (((word >> 22) & 0x1) == 0)
   5682                                                                 {
   5683                                                                   if (((word >> 23) & 0x1) == 0)
   5684                                                                     {
   5685                                                                       /* 33222222222211111111110000000000
   5686                                                                          10987654321098765432109876543210
   5687                                                                          xxxxxxxxxx101111xxxx01000x100000
   5688                                                                          uqincb.  */
   5689                                                                       return 1935;
   5690                                                                     }
   5691                                                                   else
   5692                                                                     {
   5693                                                                       /* 33222222222211111111110000000000
   5694                                                                          10987654321098765432109876543210
   5695                                                                          xxxxxxxxxx101111xxxx01010x100000
   5696                                                                          uqincw.  */
   5697                                                                       return 1947;
   5698                                                                     }
   5699                                                                 }
   5700                                                               else
   5701                                                                 {
   5702                                                                   if (((word >> 23) & 0x1) == 0)
   5703                                                                     {
   5704                                                                       /* 33222222222211111111110000000000
   5705                                                                          10987654321098765432109876543210
   5706                                                                          xxxxxxxxxx101111xxxx01100x100000
   5707                                                                          uqinch.  */
   5708                                                                       return 1941;
   5709                                                                     }
   5710                                                                   else
   5711                                                                     {
   5712                                                                       /* 33222222222211111111110000000000
   5713                                                                          10987654321098765432109876543210
   5714                                                                          xxxxxxxxxx101111xxxx01110x100000
   5715                                                                          uqincd.  */
   5716                                                                       return 1938;
   5717                                                                     }
   5718                                                                 }
   5719                                                             }
   5720                                                           else
   5721                                                             {
   5722                                                               if (((word >> 22) & 0x1) == 0)
   5723                                                                 {
   5724                                                                   if (((word >> 23) & 0x1) == 0)
   5725                                                                     {
   5726                                                                       /* 33222222222211111111110000000000
   5727                                                                          10987654321098765432109876543210
   5728                                                                          xxxxxxxxxx101111xxxx11000x100000
   5729                                                                          uqincb.  */
   5730                                                                       return 1936;
   5731                                                                     }
   5732                                                                   else
   5733                                                                     {
   5734                                                                       /* 33222222222211111111110000000000
   5735                                                                          10987654321098765432109876543210
   5736                                                                          xxxxxxxxxx101111xxxx11010x100000
   5737                                                                          uqincw.  */
   5738                                                                       return 1948;
   5739                                                                     }
   5740                                                                 }
   5741                                                               else
   5742                                                                 {
   5743                                                                   if (((word >> 23) & 0x1) == 0)
   5744                                                                     {
   5745                                                                       /* 33222222222211111111110000000000
   5746                                                                          10987654321098765432109876543210
   5747                                                                          xxxxxxxxxx101111xxxx11100x100000
   5748                                                                          uqinch.  */
   5749                                                                       return 1942;
   5750                                                                     }
   5751                                                                   else
   5752                                                                     {
   5753                                                                       /* 33222222222211111111110000000000
   5754                                                                          10987654321098765432109876543210
   5755                                                                          xxxxxxxxxx101111xxxx11110x100000
   5756                                                                          uqincd.  */
   5757                                                                       return 1939;
   5758                                                                     }
   5759                                                                 }
   5760                                                             }
   5761                                                         }
   5762                                                     }
   5763                                                   else
   5764                                                     {
   5765                                                       if (((word >> 20) & 0x1) == 0)
   5766                                                         {
   5767                                                           if (((word >> 22) & 0x1) == 0)
   5768                                                             {
   5769                                                               if (((word >> 23) & 0x1) == 0)
   5770                                                                 {
   5771                                                                   /* 33222222222211111111110000000000
   5772                                                                      10987654321098765432109876543210
   5773                                                                      xxxxxxxxxx11x111xxxx01000x100000
   5774                                                                      uqdecb.  */
   5775                                                                   return 1921;
   5776                                                                 }
   5777                                                               else
   5778                                                                 {
   5779                                                                   /* 33222222222211111111110000000000
   5780                                                                      10987654321098765432109876543210
   5781                                                                      xxxxxxxxxx11x111xxxx01010x100000
   5782                                                                      uqdecw.  */
   5783                                                                   return 1933;
   5784                                                                 }
   5785                                                             }
   5786                                                           else
   5787                                                             {
   5788                                                               if (((word >> 23) & 0x1) == 0)
   5789                                                                 {
   5790                                                                   /* 33222222222211111111110000000000
   5791                                                                      10987654321098765432109876543210
   5792                                                                      xxxxxxxxxx11x111xxxx01100x100000
   5793                                                                      uqdech.  */
   5794                                                                   return 1927;
   5795                                                                 }
   5796                                                               else
   5797                                                                 {
   5798                                                                   /* 33222222222211111111110000000000
   5799                                                                      10987654321098765432109876543210
   5800                                                                      xxxxxxxxxx11x111xxxx01110x100000
   5801                                                                      uqdecd.  */
   5802                                                                   return 1924;
   5803                                                                 }
   5804                                                             }
   5805                                                         }
   5806                                                       else
   5807                                                         {
   5808                                                           if (((word >> 22) & 0x1) == 0)
   5809                                                             {
   5810                                                               if (((word >> 23) & 0x1) == 0)
   5811                                                                 {
   5812                                                                   /* 33222222222211111111110000000000
   5813                                                                      10987654321098765432109876543210
   5814                                                                      xxxxxxxxxx11x111xxxx11000x100000
   5815                                                                      uqdecb.  */
   5816                                                                   return 1922;
   5817                                                                 }
   5818                                                               else
   5819                                                                 {
   5820                                                                   /* 33222222222211111111110000000000
   5821                                                                      10987654321098765432109876543210
   5822                                                                      xxxxxxxxxx11x111xxxx11010x100000
   5823                                                                      uqdecw.  */
   5824                                                                   return 1934;
   5825                                                                 }
   5826                                                             }
   5827                                                           else
   5828                                                             {
   5829                                                               if (((word >> 23) & 0x1) == 0)
   5830                                                                 {
   5831                                                                   /* 33222222222211111111110000000000
   5832                                                                      10987654321098765432109876543210
   5833                                                                      xxxxxxxxxx11x111xxxx11100x100000
   5834                                                                      uqdech.  */
   5835                                                                   return 1928;
   5836                                                                 }
   5837                                                               else
   5838                                                                 {
   5839                                                                   /* 33222222222211111111110000000000
   5840                                                                      10987654321098765432109876543210
   5841                                                                      xxxxxxxxxx11x111xxxx11110x100000
   5842                                                                      uqdecd.  */
   5843                                                                   return 1925;
   5844                                                                 }
   5845                                                             }
   5846                                                         }
   5847                                                     }
   5848                                                 }
   5849                                             }
   5850                                         }
   5851                                       else
   5852                                         {
   5853                                           if (((word >> 22) & 0x1) == 0)
   5854                                             {
   5855                                               if (((word >> 21) & 0x1) == 0)
   5856                                                 {
   5857                                                   if (((word >> 23) & 0x1) == 0)
   5858                                                     {
   5859                                                       /* 33222222222211111111110000000000
   5860                                                          10987654321098765432109876543210
   5861                                                          xxxxxxxxxxxxx111xxxxx0000x100001
   5862                                                          prfb.  */
   5863                                                       return 1707;
   5864                                                     }
   5865                                                   else
   5866                                                     {
   5867                                                       /* 33222222222211111111110000000000
   5868                                                          10987654321098765432109876543210
   5869                                                          xxxxxxxxxxxxx111xxxxx0010x100001
   5870                                                          prfh.  */
   5871                                                       return 1721;
   5872                                                     }
   5873                                                 }
   5874                                               else
   5875                                                 {
   5876                                                   if (((word >> 23) & 0x1) == 0)
   5877                                                     {
   5878                                                       /* 33222222222211111111110000000000
   5879                                                          10987654321098765432109876543210
   5880                                                          xxxxxxxxxxxxx111xxxxx1000x100001
   5881                                                          ldff1b.  */
   5882                                                       return 1587;
   5883                                                     }
   5884                                                   else
   5885                                                     {
   5886                                                       /* 33222222222211111111110000000000
   5887                                                          10987654321098765432109876543210
   5888                                                          xxxxxxxxxxxxx111xxxxx1010x100001
   5889                                                          ldff1h.  */
   5890                                                       return 1604;
   5891                                                     }
   5892                                                 }
   5893                                             }
   5894                                           else
   5895                                             {
   5896                                               if (((word >> 23) & 0x1) == 0)
   5897                                                 {
   5898                                                   /* 33222222222211111111110000000000
   5899                                                      10987654321098765432109876543210
   5900                                                      xxxxxxxxxxxxx111xxxxxx100x100001
   5901                                                      ld1rb.  */
   5902                                                   return 1493;
   5903                                                 }
   5904                                               else
   5905                                                 {
   5906                                                   /* 33222222222211111111110000000000
   5907                                                      10987654321098765432109876543210
   5908                                                      xxxxxxxxxxxxx111xxxxxx110x100001
   5909                                                      ld1rh.  */
   5910                                                   return 1497;
   5911                                                 }
   5912                                             }
   5913                                         }
   5914                                     }
   5915                                   else
   5916                                     {
   5917                                       if (((word >> 21) & 0x1) == 0)
   5918                                         {
   5919                                           if (((word >> 22) & 0x1) == 0)
   5920                                             {
   5921                                               if (((word >> 23) & 0x1) == 0)
   5922                                                 {
   5923                                                   /* 33222222222211111111110000000000
   5924                                                      10987654321098765432109876543210
   5925                                                      xxxxxxxxxxxxx111xxxxx0000x10001x
   5926                                                      prfb.  */
   5927                                                   return 1709;
   5928                                                 }
   5929                                               else
   5930                                                 {
   5931                                                   /* 33222222222211111111110000000000
   5932                                                      10987654321098765432109876543210
   5933                                                      xxxxxxxxxxxxx111xxxxx0010x10001x
   5934                                                      prfh.  */
   5935                                                   return 1723;
   5936                                                 }
   5937                                             }
   5938                                           else
   5939                                             {
   5940                                               if (((word >> 23) & 0x1) == 0)
   5941                                                 {
   5942                                                   /* 33222222222211111111110000000000
   5943                                                      10987654321098765432109876543210
   5944                                                      xxxxxxxxxxxxx111xxxxx0100x10001x
   5945                                                      ldff1b.  */
   5946                                                   return 1586;
   5947                                                 }
   5948                                               else
   5949                                                 {
   5950                                                   /* 33222222222211111111110000000000
   5951                                                      10987654321098765432109876543210
   5952                                                      xxxxxxxxxxxxx111xxxxx0110x10001x
   5953                                                      ldff1h.  */
   5954                                                   return 1602;
   5955                                                 }
   5956                                             }
   5957                                         }
   5958                                       else
   5959                                         {
   5960                                           if (((word >> 22) & 0x1) == 0)
   5961                                             {
   5962                                               if (((word >> 23) & 0x1) == 0)
   5963                                                 {
   5964                                                   /* 33222222222211111111110000000000
   5965                                                      10987654321098765432109876543210
   5966                                                      xxxxxxxxxxxxx111xxxxx1000x10001x
   5967                                                      ldff1b.  */
   5968                                                   return 1588;
   5969                                                 }
   5970                                               else
   5971                                                 {
   5972                                                   /* 33222222222211111111110000000000
   5973                                                      10987654321098765432109876543210
   5974                                                      xxxxxxxxxxxxx111xxxxx1010x10001x
   5975                                                      ldff1h.  */
   5976                                                   return 1605;
   5977                                                 }
   5978                                             }
   5979                                           else
   5980                                             {
   5981                                               if (((word >> 23) & 0x1) == 0)
   5982                                                 {
   5983                                                   /* 33222222222211111111110000000000
   5984                                                      10987654321098765432109876543210
   5985                                                      xxxxxxxxxxxxx111xxxxx1100x10001x
   5986                                                      prfd.  */
   5987                                                   return 1713;
   5988                                                 }
   5989                                               else
   5990                                                 {
   5991                                                   /* 33222222222211111111110000000000
   5992                                                      10987654321098765432109876543210
   5993                                                      xxxxxxxxxxxxx111xxxxx1110x10001x
   5994                                                      ldff1h.  */
   5995                                                   return 1603;
   5996                                                 }
   5997                                             }
   5998                                         }
   5999                                     }
   6000                                 }
   6001                             }
   6002                         }
   6003                     }
   6004                   else
   6005                     {
   6006                       if (((word >> 21) & 0x1) == 0)
   6007                         {
   6008                           if (((word >> 15) & 0x1) == 0)
   6009                             {
   6010                               if (((word >> 30) & 0x1) == 0)
   6011                                 {
   6012                                   if (((word >> 13) & 0x1) == 0)
   6013                                     {
   6014                                       if (((word >> 14) & 0x1) == 0)
   6015                                         {
   6016                                           if (((word >> 31) & 0x1) == 0)
   6017                                             {
   6018                                               if (((word >> 4) & 0x1) == 0)
   6019                                                 {
   6020                                                   /* 33222222222211111111110000000000
   6021                                                      10987654321098765432109876543210
   6022                                                      xxxx0xxxxxxxx000xxxxx0xx0x100100
   6023                                                      cmphs.  */
   6024                                                   return 1285;
   6025                                                 }
   6026                                               else
   6027                                                 {
   6028                                                   /* 33222222222211111111110000000000
   6029                                                      10987654321098765432109876543210
   6030                                                      xxxx1xxxxxxxx000xxxxx0xx0x100100
   6031                                                      cmphi.  */
   6032                                                   return 1282;
   6033                                                 }
   6034                                             }
   6035                                           else
   6036                                             {
   6037                                               if (((word >> 23) & 0x1) == 0)
   6038                                                 {
   6039                                                   /* 33222222222211111111110000000000
   6040                                                      10987654321098765432109876543210
   6041                                                      xxxxxxxxxxxxx000xxxxx0x00x100101
   6042                                                      ld1rqb.  */
   6043                                                   return 1499;
   6044                                                 }
   6045                                               else
   6046                                                 {
   6047                                                   /* 33222222222211111111110000000000
   6048                                                      10987654321098765432109876543210
   6049                                                      xxxxxxxxxxxxx000xxxxx0x10x100101
   6050                                                      ld1rqh.  */
   6051                                                   return 1503;
   6052                                                 }
   6053                                             }
   6054                                         }
   6055                                       else
   6056                                         {
   6057                                           if (((word >> 31) & 0x1) == 0)
   6058                                             {
   6059                                               if (((word >> 4) & 0x1) == 0)
   6060                                                 {
   6061                                                   /* 33222222222211111111110000000000
   6062                                                      10987654321098765432109876543210
   6063                                                      xxxx0xxxxxxxx010xxxxx0xx0x100100
   6064                                                      cmpge.  */
   6065                                                   return 1276;
   6066                                                 }
   6067                                               else
   6068                                                 {
   6069                                                   /* 33222222222211111111110000000000
   6070                                                      10987654321098765432109876543210
   6071                                                      xxxx1xxxxxxxx010xxxxx0xx0x100100
   6072                                                      cmpgt.  */
   6073                                                   return 1279;
   6074                                                 }
   6075                                             }
   6076                                           else
   6077                                             {
   6078                                               if (((word >> 22) & 0x1) == 0)
   6079                                                 {
   6080                                                   if (((word >> 23) & 0x1) == 0)
   6081                                                     {
   6082                                                       /* 33222222222211111111110000000000
   6083                                                          10987654321098765432109876543210
   6084                                                          xxxxxxxxxxxxx010xxxxx0000x100101
   6085                                                          ld1b.  */
   6086                                                       return 1457;
   6087                                                     }
   6088                                                   else
   6089                                                     {
   6090                                                       /* 33222222222211111111110000000000
   6091                                                          10987654321098765432109876543210
   6092                                                          xxxxxxxxxxxxx010xxxxx0010x100101
   6093                                                          ld1sw.  */
   6094                                                       return 1537;
   6095                                                     }
   6096                                                 }
   6097                                               else
   6098                                                 {
   6099                                                   if (((word >> 23) & 0x1) == 0)
   6100                                                     {
   6101                                                       /* 33222222222211111111110000000000
   6102                                                          10987654321098765432109876543210
   6103                                                          xxxxxxxxxxxxx010xxxxx0100x100101
   6104                                                          ld1b.  */
   6105                                                       return 1459;
   6106                                                     }
   6107                                                   else
   6108                                                     {
   6109                                                       /* 33222222222211111111110000000000
   6110                                                          10987654321098765432109876543210
   6111                                                          xxxxxxxxxxxxx010xxxxx0110x100101
   6112                                                          ld1h.  */
   6113                                                       return 1479;
   6114                                                     }
   6115                                                 }
   6116                                             }
   6117                                         }
   6118                                     }
   6119                                   else
   6120                                     {
   6121                                       if (((word >> 14) & 0x1) == 0)
   6122                                         {
   6123                                           if (((word >> 31) & 0x1) == 0)
   6124                                             {
   6125                                               if (((word >> 4) & 0x1) == 0)
   6126                                                 {
   6127                                                   /* 33222222222211111111110000000000
   6128                                                      10987654321098765432109876543210
   6129                                                      xxxx0xxxxxxxx100xxxxx0xx0x100100
   6130                                                      cmpeq.  */
   6131                                                   return 1273;
   6132                                                 }
   6133                                               else
   6134                                                 {
   6135                                                   /* 33222222222211111111110000000000
   6136                                                      10987654321098765432109876543210
   6137                                                      xxxx1xxxxxxxx100xxxxx0xx0x100100
   6138                                                      cmpne.  */
   6139                                                   return 1296;
   6140                                                 }
   6141                                             }
   6142                                           else
   6143                                             {
   6144                                               if (((word >> 23) & 0x1) == 0)
   6145                                                 {
   6146                                                   /* 33222222222211111111110000000000
   6147                                                      10987654321098765432109876543210
   6148                                                      xxxxxxxxxxxxx100xxxxx0x00x100101
   6149                                                      ld1rqb.  */
   6150                                                   return 1498;
   6151                                                 }
   6152                                               else
   6153                                                 {
   6154                                                   /* 33222222222211111111110000000000
   6155                                                      10987654321098765432109876543210
   6156                                                      xxxxxxxxxxxxx100xxxxx0x10x100101
   6157                                                      ld1rqh.  */
   6158                                                   return 1502;
   6159                                                 }
   6160                                             }
   6161                                         }
   6162                                       else
   6163                                         {
   6164                                           if (((word >> 31) & 0x1) == 0)
   6165                                             {
   6166                                               if (((word >> 4) & 0x1) == 0)
   6167                                                 {
   6168                                                   /* 33222222222211111111110000000000
   6169                                                      10987654321098765432109876543210
   6170                                                      xxxx0xxxxxxxx110xxxxx0xx0x100100
   6171                                                      cmplt.  */
   6172                                                   return 1294;
   6173                                                 }
   6174                                               else
   6175                                                 {
   6176                                                   /* 33222222222211111111110000000000
   6177                                                      10987654321098765432109876543210
   6178                                                      xxxx1xxxxxxxx110xxxxx0xx0x100100
   6179                                                      cmple.  */
   6180                                                   return 1288;
   6181                                                 }
   6182                                             }
   6183                                           else
   6184                                             {
   6185                                               if (((word >> 22) & 0x1) == 0)
   6186                                                 {
   6187                                                   if (((word >> 23) & 0x1) == 0)
   6188                                                     {
   6189                                                       /* 33222222222211111111110000000000
   6190                                                          10987654321098765432109876543210
   6191                                                          xxxxxxxxxxxxx110xxxxx0000x100101
   6192                                                          ldff1b.  */
   6193                                                       return 1581;
   6194                                                     }
   6195                                                   else
   6196                                                     {
   6197                                                       /* 33222222222211111111110000000000
   6198                                                          10987654321098765432109876543210
   6199                                                          xxxxxxxxxxxxx110xxxxx0010x100101
   6200                                                          ldff1sw.  */
   6201                                                       return 1624;
   6202                                                     }
   6203                                                 }
   6204                                               else
   6205                                                 {
   6206                                                   if (((word >> 23) & 0x1) == 0)
   6207                                                     {
   6208                                                       /* 33222222222211111111110000000000
   6209                                                          10987654321098765432109876543210
   6210                                                          xxxxxxxxxxxxx110xxxxx0100x100101
   6211                                                          ldff1b.  */
   6212                                                       return 1583;
   6213                                                     }
   6214                                                   else
   6215                                                     {
   6216                                                       /* 33222222222211111111110000000000
   6217                                                          10987654321098765432109876543210
   6218                                                          xxxxxxxxxxxxx110xxxxx0110x100101
   6219                                                          ldff1h.  */
   6220                                                       return 1598;
   6221                                                     }
   6222                                                 }
   6223                                             }
   6224                                         }
   6225                                     }
   6226                                 }
   6227                               else
   6228                                 {
   6229                                   if (((word >> 31) & 0x1) == 0)
   6230                                     {
   6231                                       /* 33222222222211111111110000000000
   6232                                          10987654321098765432109876543210
   6233                                          xxxxxxxxxxxxxxx0xxxxx0xx0x100110
   6234                                          fcmla.  */
   6235                                       return 1342;
   6236                                     }
   6237                                   else
   6238                                     {
   6239                                       if (((word >> 13) & 0x1) == 0)
   6240                                         {
   6241                                           if (((word >> 22) & 0x1) == 0)
   6242                                             {
   6243                                               /* 33222222222211111111110000000000
   6244                                                  10987654321098765432109876543210
   6245                                                  xxxxxxxxxxxxx0x0xxxxx00x0x100111
   6246                                                  st1b.  */
   6247                                               return 1803;
   6248                                             }
   6249                                           else
   6250                                             {
   6251                                               if (((word >> 23) & 0x1) == 0)
   6252                                                 {
   6253                                                   /* 33222222222211111111110000000000
   6254                                                      10987654321098765432109876543210
   6255                                                      xxxxxxxxxxxxx0x0xxxxx0100x100111
   6256                                                      st1b.  */
   6257                                                   return 1807;
   6258                                                 }
   6259                                               else
   6260                                                 {
   6261                                                   /* 33222222222211111111110000000000
   6262                                                      10987654321098765432109876543210
   6263                                                      xxxxxxxxxxxxx0x0xxxxx0110x100111
   6264                                                      st1h.  */
   6265                                                   return 1828;
   6266                                                 }
   6267                                             }
   6268                                         }
   6269                                       else
   6270                                         {
   6271                                           if (((word >> 22) & 0x1) == 0)
   6272                                             {
   6273                                               if (((word >> 23) & 0x1) == 0)
   6274                                                 {
   6275                                                   /* 33222222222211111111110000000000
   6276                                                      10987654321098765432109876543210
   6277                                                      xxxxxxxxxxxxx1x0xxxxx0000x100111
   6278                                                      stnt1b.  */
   6279                                                   return 1873;
   6280                                                 }
   6281                                               else
   6282                                                 {
   6283                                                   /* 33222222222211111111110000000000
   6284                                                      10987654321098765432109876543210
   6285                                                      xxxxxxxxxxxxx1x0xxxxx0010x100111
   6286                                                      stnt1h.  */
   6287                                                   return 1877;
   6288                                                 }
   6289                                             }
   6290                                           else
   6291                                             {
   6292                                               if (((word >> 23) & 0x1) == 0)
   6293                                                 {
   6294                                                   /* 33222222222211111111110000000000
   6295                                                      10987654321098765432109876543210
   6296                                                      xxxxxxxxxxxxx1x0xxxxx0100x100111
   6297                                                      st3b.  */
   6298                                                   return 1857;
   6299                                                 }
   6300                                               else
   6301                                                 {
   6302                                                   /* 33222222222211111111110000000000
   6303                                                      10987654321098765432109876543210
   6304                                                      xxxxxxxxxxxxx1x0xxxxx0110x100111
   6305                                                      st3h.  */
   6306                                                   return 1861;
   6307                                                 }
   6308                                             }
   6309                                         }
   6310                                     }
   6311                                 }
   6312                             }
   6313                           else
   6314                             {
   6315                               if (((word >> 13) & 0x1) == 0)
   6316                                 {
   6317                                   if (((word >> 30) & 0x1) == 0)
   6318                                     {
   6319                                       if (((word >> 14) & 0x1) == 0)
   6320                                         {
   6321                                           if (((word >> 4) & 0x1) == 0)
   6322                                             {
   6323                                               /* 33222222222211111111110000000000
   6324                                                  10987654321098765432109876543210
   6325                                                  xxxx0xxxxxxxx001xxxxx0xx0x10010x
   6326                                                  cmpge.  */
   6327                                               return 1277;
   6328                                             }
   6329                                           else
   6330                                             {
   6331                                               /* 33222222222211111111110000000000
   6332                                                  10987654321098765432109876543210
   6333                                                  xxxx1xxxxxxxx001xxxxx0xx0x10010x
   6334                                                  cmpgt.  */
   6335                                               return 1280;
   6336                                             }
   6337                                         }
   6338                                       else
   6339                                         {
   6340                                           if (((word >> 31) & 0x1) == 0)
   6341                                             {
   6342                                               if (((word >> 4) & 0x1) == 0)
   6343                                                 {
   6344                                                   /* 33222222222211111111110000000000
   6345                                                      10987654321098765432109876543210
   6346                                                      xxxx0xxxxxxxx011xxxxx0xx0x100100
   6347                                                      cmphs.  */
   6348                                                   return 1286;
   6349                                                 }
   6350                                               else
   6351                                                 {
   6352                                                   /* 33222222222211111111110000000000
   6353                                                      10987654321098765432109876543210
   6354                                                      xxxx1xxxxxxxx011xxxxx0xx0x100100
   6355                                                      cmphi.  */
   6356                                                   return 1283;
   6357                                                 }
   6358                                             }
   6359                                           else
   6360                                             {
   6361                                               if (((word >> 22) & 0x1) == 0)
   6362                                                 {
   6363                                                   if (((word >> 23) & 0x1) == 0)
   6364                                                     {
   6365                                                       /* 33222222222211111111110000000000
   6366                                                          10987654321098765432109876543210
   6367                                                          xxxxxxxxxxxxx011xxxxx0000x100101
   6368                                                          ldnt1b.  */
   6369                                                       return 1656;
   6370                                                     }
   6371                                                   else
   6372                                                     {
   6373                                                       /* 33222222222211111111110000000000
   6374                                                          10987654321098765432109876543210
   6375                                                          xxxxxxxxxxxxx011xxxxx0010x100101
   6376                                                          ldnt1h.  */
   6377                                                       return 1660;
   6378                                                     }
   6379                                                 }
   6380                                               else
   6381                                                 {
   6382                                                   if (((word >> 23) & 0x1) == 0)
   6383                                                     {
   6384                                                       /* 33222222222211111111110000000000
   6385                                                          10987654321098765432109876543210
   6386                                                          xxxxxxxxxxxxx011xxxxx0100x100101
   6387                                                          ld3b.  */
   6388                                                       return 1564;
   6389                                                     }
   6390                                                   else
   6391                                                     {
   6392                                                       /* 33222222222211111111110000000000
   6393                                                          10987654321098765432109876543210
   6394                                                          xxxxxxxxxxxxx011xxxxx0110x100101
   6395                                                          ld3h.  */
   6396                                                       return 1568;
   6397                                                     }
   6398                                                 }
   6399                                             }
   6400                                         }
   6401                                     }
   6402                                   else
   6403                                     {
   6404                                       if (((word >> 31) & 0x1) == 0)
   6405                                         {
   6406                                           /* 33222222222211111111110000000000
   6407                                              10987654321098765432109876543210
   6408                                              xxxxxxxxxxxxx0x1xxxxx0xx0x100110
   6409                                              fcadd.  */
   6410                                           return 1341;
   6411                                         }
   6412                                       else
   6413                                         {
   6414                                           if (((word >> 22) & 0x1) == 0)
   6415                                             {
   6416                                               if (((word >> 23) & 0x1) == 0)
   6417                                                 {
   6418                                                   /* 33222222222211111111110000000000
   6419                                                      10987654321098765432109876543210
   6420                                                      xxxxxxxxxxxxx0x1xxxxx0000x100111
   6421                                                      st1b.  */
   6422                                                   return 1804;
   6423                                                 }
   6424                                               else
   6425                                                 {
   6426                                                   /* 33222222222211111111110000000000
   6427                                                      10987654321098765432109876543210
   6428                                                      xxxxxxxxxxxxx0x1xxxxx0010x100111
   6429                                                      st1h.  */
   6430                                                   return 1823;
   6431                                                 }
   6432                                             }
   6433                                           else
   6434                                             {
   6435                                               if (((word >> 23) & 0x1) == 0)
   6436                                                 {
   6437                                                   /* 33222222222211111111110000000000
   6438                                                      10987654321098765432109876543210
   6439                                                      xxxxxxxxxxxxx0x1xxxxx0100x100111
   6440                                                      st1b.  */
   6441                                                   return 1808;
   6442                                                 }
   6443                                               else
   6444                                                 {
   6445                                                   /* 33222222222211111111110000000000
   6446                                                      10987654321098765432109876543210
   6447                                                      xxxxxxxxxxxxx0x1xxxxx0110x100111
   6448                                                      st1h.  */
   6449                                                   return 1829;
   6450                                                 }
   6451                                             }
   6452                                         }
   6453                                     }
   6454                                 }
   6455                               else
   6456                                 {
   6457                                   if (((word >> 14) & 0x1) == 0)
   6458                                     {
   6459                                       if (((word >> 30) & 0x1) == 0)
   6460                                         {
   6461                                           if (((word >> 31) & 0x1) == 0)
   6462                                             {
   6463                                               if (((word >> 4) & 0x1) == 0)
   6464                                                 {
   6465                                                   /* 33222222222211111111110000000000
   6466                                                      10987654321098765432109876543210
   6467                                                      xxxx0xxxxxxxx101xxxxx0xx0x100100
   6468                                                      cmpeq.  */
   6469                                                   return 1274;
   6470                                                 }
   6471                                               else
   6472                                                 {
   6473                                                   /* 33222222222211111111110000000000
   6474                                                      10987654321098765432109876543210
   6475                                                      xxxx1xxxxxxxx101xxxxx0xx0x100100
   6476                                                      cmpne.  */
   6477                                                   return 1297;
   6478                                                 }
   6479                                             }
   6480                                           else
   6481                                             {
   6482                                               if (((word >> 20) & 0x1) == 0)
   6483                                                 {
   6484                                                   if (((word >> 22) & 0x1) == 0)
   6485                                                     {
   6486                                                       if (((word >> 23) & 0x1) == 0)
   6487                                                         {
   6488                                                           /* 33222222222211111111110000000000
   6489                                                              10987654321098765432109876543210
   6490                                                              xxxxxxxxxxxxx101xxxx00000x100101
   6491                                                              ld1b.  */
   6492                                                           return 1464;
   6493                                                         }
   6494                                                       else
   6495                                                         {
   6496                                                           /* 33222222222211111111110000000000
   6497                                                              10987654321098765432109876543210
   6498                                                              xxxxxxxxxxxxx101xxxx00010x100101
   6499                                                              ld1sw.  */
   6500                                                           return 1542;
   6501                                                         }
   6502                                                     }
   6503                                                   else
   6504                                                     {
   6505                                                       if (((word >> 23) & 0x1) == 0)
   6506                                                         {
   6507                                                           /* 33222222222211111111110000000000
   6508                                                              10987654321098765432109876543210
   6509                                                              xxxxxxxxxxxxx101xxxx00100x100101
   6510                                                              ld1b.  */
   6511                                                           return 1466;
   6512                                                         }
   6513                                                       else
   6514                                                         {
   6515                                                           /* 33222222222211111111110000000000
   6516                                                              10987654321098765432109876543210
   6517                                                              xxxxxxxxxxxxx101xxxx00110x100101
   6518                                                              ld1h.  */
   6519                                                           return 1487;
   6520                                                         }
   6521                                                     }
   6522                                                 }
   6523                                               else
   6524                                                 {
   6525                                                   if (((word >> 22) & 0x1) == 0)
   6526                                                     {
   6527                                                       if (((word >> 23) & 0x1) == 0)
   6528                                                         {
   6529                                                           /* 33222222222211111111110000000000
   6530                                                              10987654321098765432109876543210
   6531                                                              xxxxxxxxxxxxx101xxxx10000x100101
   6532                                                              ldnf1b.  */
   6533                                                           return 1640;
   6534                                                         }
   6535                                                       else
   6536                                                         {
   6537                                                           /* 33222222222211111111110000000000
   6538                                                              10987654321098765432109876543210
   6539                                                              xxxxxxxxxxxxx101xxxx10010x100101
   6540                                                              ldnf1sw.  */
   6541                                                           return 1653;
   6542                                                         }
   6543                                                     }
   6544                                                   else
   6545                                                     {
   6546                                                       if (((word >> 23) & 0x1) == 0)
   6547                                                         {
   6548                                                           /* 33222222222211111111110000000000
   6549                                                              10987654321098765432109876543210
   6550                                                              xxxxxxxxxxxxx101xxxx10100x100101
   6551                                                              ldnf1b.  */
   6552                                                           return 1642;
   6553                                                         }
   6554                                                       else
   6555                                                         {
   6556                                                           /* 33222222222211111111110000000000
   6557                                                              10987654321098765432109876543210
   6558                                                              xxxxxxxxxxxxx101xxxx10110x100101
   6559                                                              ldnf1h.  */
   6560                                                           return 1646;
   6561                                                         }
   6562                                                     }
   6563                                                 }
   6564                                             }
   6565                                         }
   6566                                       else
   6567                                         {
   6568                                           if (((word >> 22) & 0x1) == 0)
   6569                                             {
   6570                                               if (((word >> 23) & 0x1) == 0)
   6571                                                 {
   6572                                                   /* 33222222222211111111110000000000
   6573                                                      10987654321098765432109876543210
   6574                                                      xxxxxxxxxxxxx101xxxxx0000x10011x
   6575                                                      st1b.  */
   6576                                                   return 1805;
   6577                                                 }
   6578                                               else
   6579                                                 {
   6580                                                   /* 33222222222211111111110000000000
   6581                                                      10987654321098765432109876543210
   6582                                                      xxxxxxxxxxxxx101xxxxx0010x10011x
   6583                                                      st1h.  */
   6584                                                   return 1824;
   6585                                                 }
   6586                                             }
   6587                                           else
   6588                                             {
   6589                                               if (((word >> 23) & 0x1) == 0)
   6590                                                 {
   6591                                                   /* 33222222222211111111110000000000
   6592                                                      10987654321098765432109876543210
   6593                                                      xxxxxxxxxxxxx101xxxxx0100x10011x
   6594                                                      st1b.  */
   6595                                                   return 1812;
   6596                                                 }
   6597                                               else
   6598                                                 {
   6599                                                   /* 33222222222211111111110000000000
   6600                                                      10987654321098765432109876543210
   6601                                                      xxxxxxxxxxxxx101xxxxx0110x10011x
   6602                                                      st1h.  */
   6603                                                   return 1833;
   6604                                                 }
   6605                                             }
   6606                                         }
   6607                                     }
   6608                                   else
   6609                                     {
   6610                                       if (((word >> 30) & 0x1) == 0)
   6611                                         {
   6612                                           if (((word >> 31) & 0x1) == 0)
   6613                                             {
   6614                                               if (((word >> 4) & 0x1) == 0)
   6615                                                 {
   6616                                                   /* 33222222222211111111110000000000
   6617                                                      10987654321098765432109876543210
   6618                                                      xxxx0xxxxxxxx111xxxxx0xx0x100100
   6619                                                      cmplo.  */
   6620                                                   return 1290;
   6621                                                 }
   6622                                               else
   6623                                                 {
   6624                                                   /* 33222222222211111111110000000000
   6625                                                      10987654321098765432109876543210
   6626                                                      xxxx1xxxxxxxx111xxxxx0xx0x100100
   6627                                                      cmpls.  */
   6628                                                   return 1292;
   6629                                                 }
   6630                                             }
   6631                                           else
   6632                                             {
   6633                                               if (((word >> 22) & 0x1) == 0)
   6634                                                 {
   6635                                                   if (((word >> 23) & 0x1) == 0)
   6636                                                     {
   6637                                                       /* 33222222222211111111110000000000
   6638                                                          10987654321098765432109876543210
   6639                                                          xxxxxxxxxxxxx111xxxxx0000x100101
   6640                                                          ldnt1b.  */
   6641                                                       return 1657;
   6642                                                     }
   6643                                                   else
   6644                                                     {
   6645                                                       /* 33222222222211111111110000000000
   6646                                                          10987654321098765432109876543210
   6647                                                          xxxxxxxxxxxxx111xxxxx0010x100101
   6648                                                          ldnt1h.  */
   6649                                                       return 1661;
   6650                                                     }
   6651                                                 }
   6652                                               else
   6653                                                 {
   6654                                                   if (((word >> 23) & 0x1) == 0)
   6655                                                     {
   6656                                                       /* 33222222222211111111110000000000
   6657                                                          10987654321098765432109876543210
   6658                                                          xxxxxxxxxxxxx111xxxxx0100x100101
   6659                                                          ld3b.  */
   6660                                                       return 1565;
   6661                                                     }
   6662                                                   else
   6663                                                     {
   6664                                                       /* 33222222222211111111110000000000
   6665                                                          10987654321098765432109876543210
   6666                                                          xxxxxxxxxxxxx111xxxxx0110x100101
   6667                                                          ld3h.  */
   6668                                                       return 1569;
   6669                                                     }
   6670                                                 }
   6671                                             }
   6672                                         }
   6673                                       else
   6674                                         {
   6675                                           if (((word >> 20) & 0x1) == 0)
   6676                                             {
   6677                                               if (((word >> 22) & 0x1) == 0)
   6678                                                 {
   6679                                                   /* 33222222222211111111110000000000
   6680                                                      10987654321098765432109876543210
   6681                                                      xxxxxxxxxxxxx111xxxx000x0x10011x
   6682                                                      st1b.  */
   6683                                                   return 1810;
   6684                                                 }
   6685                                               else
   6686                                                 {
   6687                                                   if (((word >> 23) & 0x1) == 0)
   6688                                                     {
   6689                                                       /* 33222222222211111111110000000000
   6690                                                          10987654321098765432109876543210
   6691                                                          xxxxxxxxxxxxx111xxxx00100x10011x
   6692                                                          st1b.  */
   6693                                                       return 1813;
   6694                                                     }
   6695                                                   else
   6696                                                     {
   6697                                                       /* 33222222222211111111110000000000
   6698                                                          10987654321098765432109876543210
   6699                                                          xxxxxxxxxxxxx111xxxx00110x10011x
   6700                                                          st1h.  */
   6701                                                       return 1834;
   6702                                                     }
   6703                                                 }
   6704                                             }
   6705                                           else
   6706                                             {
   6707                                               if (((word >> 22) & 0x1) == 0)
   6708                                                 {
   6709                                                   if (((word >> 23) & 0x1) == 0)
   6710                                                     {
   6711                                                       /* 33222222222211111111110000000000
   6712                                                          10987654321098765432109876543210
   6713                                                          xxxxxxxxxxxxx111xxxx10000x10011x
   6714                                                          stnt1b.  */
   6715                                                       return 1874;
   6716                                                     }
   6717                                                   else
   6718                                                     {
   6719                                                       /* 33222222222211111111110000000000
   6720                                                          10987654321098765432109876543210
   6721                                                          xxxxxxxxxxxxx111xxxx10010x10011x
   6722                                                          stnt1h.  */
   6723                                                       return 1878;
   6724                                                     }
   6725                                                 }
   6726                                               else
   6727                                                 {
   6728                                                   if (((word >> 23) & 0x1) == 0)
   6729                                                     {
   6730                                                       /* 33222222222211111111110000000000
   6731                                                          10987654321098765432109876543210
   6732                                                          xxxxxxxxxxxxx111xxxx10100x10011x
   6733                                                          st3b.  */
   6734                                                       return 1858;
   6735                                                     }
   6736                                                   else
   6737                                                     {
   6738                                                       /* 33222222222211111111110000000000
   6739                                                          10987654321098765432109876543210
   6740                                                          xxxxxxxxxxxxx111xxxx10110x10011x
   6741                                                          st3h.  */
   6742                                                       return 1862;
   6743                                                     }
   6744                                                 }
   6745                                             }
   6746                                         }
   6747                                     }
   6748                                 }
   6749                             }
   6750                         }
   6751                       else
   6752                         {
   6753                           if (((word >> 13) & 0x1) == 0)
   6754                             {
   6755                               if (((word >> 30) & 0x1) == 0)
   6756                                 {
   6757                                   if (((word >> 31) & 0x1) == 0)
   6758                                     {
   6759                                       if (((word >> 4) & 0x1) == 0)
   6760                                         {
   6761                                           /* 33222222222211111111110000000000
   6762                                              10987654321098765432109876543210
   6763                                              xxxx0xxxxxxxx0xxxxxxx1xx0x100100
   6764                                              cmphs.  */
   6765                                           return 1287;
   6766                                         }
   6767                                       else
   6768                                         {
   6769                                           /* 33222222222211111111110000000000
   6770                                              10987654321098765432109876543210
   6771                                              xxxx1xxxxxxxx0xxxxxxx1xx0x100100
   6772                                              cmphi.  */
   6773                                           return 1284;
   6774                                         }
   6775                                     }
   6776                                   else
   6777                                     {
   6778                                       if (((word >> 15) & 0x1) == 0)
   6779                                         {
   6780                                           if (((word >> 22) & 0x1) == 0)
   6781                                             {
   6782                                               if (((word >> 23) & 0x1) == 0)
   6783                                                 {
   6784                                                   /* 33222222222211111111110000000000
   6785                                                      10987654321098765432109876543210
   6786                                                      xxxxxxxxxxxxx0x0xxxxx1000x100101
   6787                                                      ld1b.  */
   6788                                                   return 1458;
   6789                                                 }
   6790                                               else
   6791                                                 {
   6792                                                   /* 33222222222211111111110000000000
   6793                                                      10987654321098765432109876543210
   6794                                                      xxxxxxxxxxxxx0x0xxxxx1010x100101
   6795                                                      ld1h.  */
   6796                                                   return 1478;
   6797                                                 }
   6798                                             }
   6799                                           else
   6800                                             {
   6801                                               if (((word >> 23) & 0x1) == 0)
   6802                                                 {
   6803                                                   /* 33222222222211111111110000000000
   6804                                                      10987654321098765432109876543210
   6805                                                      xxxxxxxxxxxxx0x0xxxxx1100x100101
   6806                                                      ld1b.  */
   6807                                                   return 1460;
   6808                                                 }
   6809                                               else
   6810                                                 {
   6811                                                   /* 33222222222211111111110000000000
   6812                                                      10987654321098765432109876543210
   6813                                                      xxxxxxxxxxxxx0x0xxxxx1110x100101
   6814                                                      ld1h.  */
   6815                                                   return 1480;
   6816                                                 }
   6817                                             }
   6818                                         }
   6819                                       else
   6820                                         {
   6821                                           if (((word >> 22) & 0x1) == 0)
   6822                                             {
   6823                                               if (((word >> 23) & 0x1) == 0)
   6824                                                 {
   6825                                                   /* 33222222222211111111110000000000
   6826                                                      10987654321098765432109876543210
   6827                                                      xxxxxxxxxxxxx0x1xxxxx1000x100101
   6828                                                      ld2b.  */
   6829                                                   return 1556;
   6830                                                 }
   6831                                               else
   6832                                                 {
   6833                                                   /* 33222222222211111111110000000000
   6834                                                      10987654321098765432109876543210
   6835                                                      xxxxxxxxxxxxx0x1xxxxx1010x100101
   6836                                                      ld2h.  */
   6837                                                   return 1560;
   6838                                                 }
   6839                                             }
   6840                                           else
   6841                                             {
   6842                                               if (((word >> 23) & 0x1) == 0)
   6843                                                 {
   6844                                                   /* 33222222222211111111110000000000
   6845                                                      10987654321098765432109876543210
   6846                                                      xxxxxxxxxxxxx0x1xxxxx1100x100101
   6847                                                      ld4b.  */
   6848                                                   return 1572;
   6849                                                 }
   6850                                               else
   6851                                                 {
   6852                                                   /* 33222222222211111111110000000000
   6853                                                      10987654321098765432109876543210
   6854                                                      xxxxxxxxxxxxx0x1xxxxx1110x100101
   6855                                                      ld4h.  */
   6856                                                   return 1576;
   6857                                                 }
   6858                                             }
   6859                                         }
   6860                                     }
   6861                                 }
   6862                               else
   6863                                 {
   6864                                   if (((word >> 15) & 0x1) == 0)
   6865                                     {
   6866                                       if (((word >> 14) & 0x1) == 0)
   6867                                         {
   6868                                           if (((word >> 12) & 0x1) == 0)
   6869                                             {
   6870                                               if (((word >> 10) & 0x1) == 0)
   6871                                                 {
   6872                                                   if (((word >> 23) & 0x1) == 0)
   6873                                                     {
   6874                                                       /* 33222222222211111111110000000000
   6875                                                          10987654321098765432109876543210
   6876                                                          xxxxxxxxxx0x0000xxxxx1x00x10011x
   6877                                                          fmla.  */
   6878                                                       return 1395;
   6879                                                     }
   6880                                                   else
   6881                                                     {
   6882                                                       if (((word >> 22) & 0x1) == 0)
   6883                                                         {
   6884                                                           /* 33222222222211111111110000000000
   6885                                                              10987654321098765432109876543210
   6886                                                              xxxxxxxxxx0x0000xxxxx1010x10011x
   6887                                                              fmla.  */
   6888                                                           return 1396;
   6889                                                         }
   6890                                                       else
   6891                                                         {
   6892                                                           /* 33222222222211111111110000000000
   6893                                                              10987654321098765432109876543210
   6894                                                              xxxxxxxxxx0x0000xxxxx1110x10011x
   6895                                                              fmla.  */
   6896                                                           return 1397;
   6897                                                         }
   6898                                                     }
   6899                                                 }
   6900                                               else
   6901                                                 {
   6902                                                   if (((word >> 23) & 0x1) == 0)
   6903                                                     {
   6904                                                       /* 33222222222211111111110000000000
   6905                                                          10987654321098765432109876543210
   6906                                                          xxxxxxxxxx1x0000xxxxx1x00x10011x
   6907                                                          fmls.  */
   6908                                                       return 1399;
   6909                                                     }
   6910                                                   else
   6911                                                     {
   6912                                                       if (((word >> 22) & 0x1) == 0)
   6913                                                         {
   6914                                                           /* 33222222222211111111110000000000
   6915                                                              10987654321098765432109876543210
   6916                                                              xxxxxxxxxx1x0000xxxxx1010x10011x
   6917                                                              fmls.  */
   6918                                                           return 1400;
   6919                                                         }
   6920                                                       else
   6921                                                         {
   6922                                                           /* 33222222222211111111110000000000
   6923                                                              10987654321098765432109876543210
   6924                                                              xxxxxxxxxx1x0000xxxxx1110x10011x
   6925                                                              fmls.  */
   6926                                                           return 1401;
   6927                                                         }
   6928                                                     }
   6929                                                 }
   6930                                             }
   6931                                           else
   6932                                             {
   6933                                               if (((word >> 22) & 0x1) == 0)
   6934                                                 {
   6935                                                   /* 33222222222211111111110000000000
   6936                                                      10987654321098765432109876543210
   6937                                                      xxxxxxxxxxxx1000xxxxx10x0x10011x
   6938                                                      fcmla.  */
   6939                                                   return 1343;
   6940                                                 }
   6941                                               else
   6942                                                 {
   6943                                                   /* 33222222222211111111110000000000
   6944                                                      10987654321098765432109876543210
   6945                                                      xxxxxxxxxxxx1000xxxxx11x0x10011x
   6946                                                      fcmla.  */
   6947                                                   return 1344;
   6948                                                 }
   6949                                             }
   6950                                         }
   6951                                       else
   6952                                         {
   6953                                           if (((word >> 22) & 0x1) == 0)
   6954                                             {
   6955                                               if (((word >> 23) & 0x1) == 0)
   6956                                                 {
   6957                                                   /* 33222222222211111111110000000000
   6958                                                      10987654321098765432109876543210
   6959                                                      xxxxxxxxxxxxx010xxxxx1000x10011x
   6960                                                      st1b.  */
   6961                                                   return 1806;
   6962                                                 }
   6963                                               else
   6964                                                 {
   6965                                                   /* 33222222222211111111110000000000
   6966                                                      10987654321098765432109876543210
   6967                                                      xxxxxxxxxxxxx010xxxxx1010x10011x
   6968                                                      st1h.  */
   6969                                                   return 1825;
   6970                                                 }
   6971                                             }
   6972                                           else
   6973                                             {
   6974                                               if (((word >> 23) & 0x1) == 0)
   6975                                                 {
   6976                                                   /* 33222222222211111111110000000000
   6977                                                      10987654321098765432109876543210
   6978                                                      xxxxxxxxxxxxx010xxxxx1100x10011x
   6979                                                      st1b.  */
   6980                                                   return 1809;
   6981                                                 }
   6982                                               else
   6983                                                 {
   6984                                                   /* 33222222222211111111110000000000
   6985                                                      10987654321098765432109876543210
   6986                                                      xxxxxxxxxxxxx010xxxxx1110x10011x
   6987                                                      st1h.  */
   6988                                                   return 1830;
   6989                                                 }
   6990                                             }
   6991                                         }
   6992                                     }
   6993                                   else
   6994                                     {
   6995                                       if (((word >> 22) & 0x1) == 0)
   6996                                         {
   6997                                           /* 33222222222211111111110000000000
   6998                                              10987654321098765432109876543210
   6999                                              xxxxxxxxxxxxx0x1xxxxx10x0x10011x
   7000                                              st1h.  */
   7001                                           return 1826;
   7002                                         }
   7003                                       else
   7004                                         {
   7005                                           /* 33222222222211111111110000000000
   7006                                              10987654321098765432109876543210
   7007                                              xxxxxxxxxxxxx0x1xxxxx11x0x10011x
   7008                                              st1h.  */
   7009                                           return 1831;
   7010                                         }
   7011                                     }
   7012                                 }
   7013                             }
   7014                           else
   7015                             {
   7016                               if (((word >> 30) & 0x1) == 0)
   7017                                 {
   7018                                   if (((word >> 31) & 0x1) == 0)
   7019                                     {
   7020                                       if (((word >> 4) & 0x1) == 0)
   7021                                         {
   7022                                           /* 33222222222211111111110000000000
   7023                                              10987654321098765432109876543210
   7024                                              xxxx0xxxxxxxx1xxxxxxx1xx0x100100
   7025                                              cmplo.  */
   7026                                           return 1291;
   7027                                         }
   7028                                       else
   7029                                         {
   7030                                           /* 33222222222211111111110000000000
   7031                                              10987654321098765432109876543210
   7032                                              xxxx1xxxxxxxx1xxxxxxx1xx0x100100
   7033                                              cmpls.  */
   7034                                           return 1293;
   7035                                         }
   7036                                     }
   7037                                   else
   7038                                     {
   7039                                       if (((word >> 14) & 0x1) == 0)
   7040                                         {
   7041                                           if (((word >> 20) & 0x1) == 0)
   7042                                             {
   7043                                               if (((word >> 22) & 0x1) == 0)
   7044                                                 {
   7045                                                   if (((word >> 23) & 0x1) == 0)
   7046                                                     {
   7047                                                       /* 33222222222211111111110000000000
   7048                                                          10987654321098765432109876543210
   7049                                                          xxxxxxxxxxxxx10xxxxx01000x100101
   7050                                                          ld1b.  */
   7051                                                       return 1465;
   7052                                                     }
   7053                                                   else
   7054                                                     {
   7055                                                       /* 33222222222211111111110000000000
   7056                                                          10987654321098765432109876543210
   7057                                                          xxxxxxxxxxxxx10xxxxx01010x100101
   7058                                                          ld1h.  */
   7059                                                       return 1486;
   7060                                                     }
   7061                                                 }
   7062                                               else
   7063                                                 {
   7064                                                   if (((word >> 23) & 0x1) == 0)
   7065                                                     {
   7066                                                       /* 33222222222211111111110000000000
   7067                                                          10987654321098765432109876543210
   7068                                                          xxxxxxxxxxxxx10xxxxx01100x100101
   7069                                                          ld1b.  */
   7070                                                       return 1467;
   7071                                                     }
   7072                                                   else
   7073                                                     {
   7074                                                       /* 33222222222211111111110000000000
   7075                                                          10987654321098765432109876543210
   7076                                                          xxxxxxxxxxxxx10xxxxx01110x100101
   7077                                                          ld1h.  */
   7078                                                       return 1488;
   7079                                                     }
   7080                                                 }
   7081                                             }
   7082                                           else
   7083                                             {
   7084                                               if (((word >> 22) & 0x1) == 0)
   7085                                                 {
   7086                                                   if (((word >> 23) & 0x1) == 0)
   7087                                                     {
   7088                                                       /* 33222222222211111111110000000000
   7089                                                          10987654321098765432109876543210
   7090                                                          xxxxxxxxxxxxx10xxxxx11000x100101
   7091                                                          ldnf1b.  */
   7092                                                       return 1641;
   7093                                                     }
   7094                                                   else
   7095                                                     {
   7096                                                       /* 33222222222211111111110000000000
   7097                                                          10987654321098765432109876543210
   7098                                                          xxxxxxxxxxxxx10xxxxx11010x100101
   7099                                                          ldnf1h.  */
   7100                                                       return 1645;
   7101                                                     }
   7102                                                 }
   7103                                               else
   7104                                                 {
   7105                                                   if (((word >> 23) & 0x1) == 0)
   7106                                                     {
   7107                                                       /* 33222222222211111111110000000000
   7108                                                          10987654321098765432109876543210
   7109                                                          xxxxxxxxxxxxx10xxxxx11100x100101
   7110                                                          ldnf1b.  */
   7111                                                       return 1643;
   7112                                                     }
   7113                                                   else
   7114                                                     {
   7115                                                       /* 33222222222211111111110000000000
   7116                                                          10987654321098765432109876543210
   7117                                                          xxxxxxxxxxxxx10xxxxx11110x100101
   7118                                                          ldnf1h.  */
   7119                                                       return 1647;
   7120                                                     }
   7121                                                 }
   7122                                             }
   7123                                         }
   7124                                       else
   7125                                         {
   7126                                           if (((word >> 15) & 0x1) == 0)
   7127                                             {
   7128                                               if (((word >> 22) & 0x1) == 0)
   7129                                                 {
   7130                                                   if (((word >> 23) & 0x1) == 0)
   7131                                                     {
   7132                                                       /* 33222222222211111111110000000000
   7133                                                          10987654321098765432109876543210
   7134                                                          xxxxxxxxxxxxx110xxxxx1000x100101
   7135                                                          ldff1b.  */
   7136                                                       return 1582;
   7137                                                     }
   7138                                                   else
   7139                                                     {
   7140                                                       /* 33222222222211111111110000000000
   7141                                                          10987654321098765432109876543210
   7142                                                          xxxxxxxxxxxxx110xxxxx1010x100101
   7143                                                          ldff1h.  */
   7144                                                       return 1597;
   7145                                                     }
   7146                                                 }
   7147                                               else
   7148                                                 {
   7149                                                   if (((word >> 23) & 0x1) == 0)
   7150                                                     {
   7151                                                       /* 33222222222211111111110000000000
   7152                                                          10987654321098765432109876543210
   7153                                                          xxxxxxxxxxxxx110xxxxx1100x100101
   7154                                                          ldff1b.  */
   7155                                                       return 1584;
   7156                                                     }
   7157                                                   else
   7158                                                     {
   7159                                                       /* 33222222222211111111110000000000
   7160                                                          10987654321098765432109876543210
   7161                                                          xxxxxxxxxxxxx110xxxxx1110x100101
   7162                                                          ldff1h.  */
   7163                                                       return 1599;
   7164                                                     }
   7165                                                 }
   7166                                             }
   7167                                           else
   7168                                             {
   7169                                               if (((word >> 22) & 0x1) == 0)
   7170                                                 {
   7171                                                   if (((word >> 23) & 0x1) == 0)
   7172                                                     {
   7173                                                       /* 33222222222211111111110000000000
   7174                                                          10987654321098765432109876543210
   7175                                                          xxxxxxxxxxxxx111xxxxx1000x100101
   7176                                                          ld2b.  */
   7177                                                       return 1557;
   7178                                                     }
   7179                                                   else
   7180                                                     {
   7181                                                       /* 33222222222211111111110000000000
   7182                                                          10987654321098765432109876543210
   7183                                                          xxxxxxxxxxxxx111xxxxx1010x100101
   7184                                                          ld2h.  */
   7185                                                       return 1561;
   7186                                                     }
   7187                                                 }
   7188                                               else
   7189                                                 {
   7190                                                   if (((word >> 23) & 0x1) == 0)
   7191                                                     {
   7192                                                       /* 33222222222211111111110000000000
   7193                                                          10987654321098765432109876543210
   7194                                                          xxxxxxxxxxxxx111xxxxx1100x100101
   7195                                                          ld4b.  */
   7196                                                       return 1573;
   7197                                                     }
   7198                                                   else
   7199                                                     {
   7200                                                       /* 33222222222211111111110000000000
   7201                                                          10987654321098765432109876543210
   7202                                                          xxxxxxxxxxxxx111xxxxx1110x100101
   7203                                                          ld4h.  */
   7204                                                       return 1577;
   7205                                                     }
   7206                                                 }
   7207                                             }
   7208                                         }
   7209                                     }
   7210                                 }
   7211                               else
   7212                                 {
   7213                                   if (((word >> 14) & 0x1) == 0)
   7214                                     {
   7215                                       if (((word >> 15) & 0x1) == 0)
   7216                                         {
   7217                                           if (((word >> 23) & 0x1) == 0)
   7218                                             {
   7219                                               /* 33222222222211111111110000000000
   7220                                                  10987654321098765432109876543210
   7221                                                  xxxxxxxxxxxxx100xxxxx1x00x10011x
   7222                                                  fmul.  */
   7223                                               return 1406;
   7224                                             }
   7225                                           else
   7226                                             {
   7227                                               if (((word >> 22) & 0x1) == 0)
   7228                                                 {
   7229                                                   /* 33222222222211111111110000000000
   7230                                                      10987654321098765432109876543210
   7231                                                      xxxxxxxxxxxxx100xxxxx1010x10011x
   7232                                                      fmul.  */
   7233                                                   return 1407;
   7234                                                 }
   7235                                               else
   7236                                                 {
   7237                                                   /* 33222222222211111111110000000000
   7238                                                      10987654321098765432109876543210
   7239                                                      xxxxxxxxxxxxx100xxxxx1110x10011x
   7240                                                      fmul.  */
   7241                                                   return 1408;
   7242                                                 }
   7243                                             }
   7244                                         }
   7245                                       else
   7246                                         {
   7247                                           if (((word >> 22) & 0x1) == 0)
   7248                                             {
   7249                                               /* 33222222222211111111110000000000
   7250                                                  10987654321098765432109876543210
   7251                                                  xxxxxxxxxxxxx101xxxxx10x0x10011x
   7252                                                  st1h.  */
   7253                                               return 1827;
   7254                                             }
   7255                                           else
   7256                                             {
   7257                                               if (((word >> 23) & 0x1) == 0)
   7258                                                 {
   7259                                                   /* 33222222222211111111110000000000
   7260                                                      10987654321098765432109876543210
   7261                                                      xxxxxxxxxxxxx101xxxxx1100x10011x
   7262                                                      st1b.  */
   7263                                                   return 1814;
   7264                                                 }
   7265                                               else
   7266                                                 {
   7267                                                   /* 33222222222211111111110000000000
   7268                                                      10987654321098765432109876543210
   7269                                                      xxxxxxxxxxxxx101xxxxx1110x10011x
   7270                                                      st1h.  */
   7271                                                   return 1835;
   7272                                                 }
   7273                                             }
   7274                                         }
   7275                                     }
   7276                                   else
   7277                                     {
   7278                                       if (((word >> 15) & 0x1) == 0)
   7279                                         {
   7280                                           if (((word >> 22) & 0x1) == 0)
   7281                                             {
   7282                                               if (((word >> 23) & 0x1) == 0)
   7283                                                 {
   7284                                                   /* 33222222222211111111110000000000
   7285                                                      10987654321098765432109876543210
   7286                                                      xxxxxxxxxxxxx110xxxxx1000x10011x
   7287                                                      st2b.  */
   7288                                                   return 1849;
   7289                                                 }
   7290                                               else
   7291                                                 {
   7292                                                   /* 33222222222211111111110000000000
   7293                                                      10987654321098765432109876543210
   7294                                                      xxxxxxxxxxxxx110xxxxx1010x10011x
   7295                                                      st2h.  */
   7296                                                   return 1853;
   7297                                                 }
   7298                                             }
   7299                                           else
   7300                                             {
   7301                                               if (((word >> 23) & 0x1) == 0)
   7302                                                 {
   7303                                                   /* 33222222222211111111110000000000
   7304                                                      10987654321098765432109876543210
   7305                                                      xxxxxxxxxxxxx110xxxxx1100x10011x
   7306                                                      st4b.  */
   7307                                                   return 1865;
   7308                                                 }
   7309                                               else
   7310                                                 {
   7311                                                   /* 33222222222211111111110000000000
   7312                                                      10987654321098765432109876543210
   7313                                                      xxxxxxxxxxxxx110xxxxx1110x10011x
   7314                                                      st4h.  */
   7315                                                   return 1869;
   7316                                                 }
   7317                                             }
   7318                                         }
   7319                                       else
   7320                                         {
   7321                                           if (((word >> 20) & 0x1) == 0)
   7322                                             {
   7323                                               if (((word >> 22) & 0x1) == 0)
   7324                                                 {
   7325                                                   if (((word >> 23) & 0x1) == 0)
   7326                                                     {
   7327                                                       /* 33222222222211111111110000000000
   7328                                                          10987654321098765432109876543210
   7329                                                          xxxxxxxxxxxxx111xxxx01000x10011x
   7330                                                          st1b.  */
   7331                                                       return 1811;
   7332                                                     }
   7333                                                   else
   7334                                                     {
   7335                                                       /* 33222222222211111111110000000000
   7336                                                          10987654321098765432109876543210
   7337                                                          xxxxxxxxxxxxx111xxxx01010x10011x
   7338                                                          st1h.  */
   7339                                                       return 1832;
   7340                                                     }
   7341                                                 }
   7342                                               else
   7343                                                 {
   7344                                                   if (((word >> 23) & 0x1) == 0)
   7345                                                     {
   7346                                                       /* 33222222222211111111110000000000
   7347                                                          10987654321098765432109876543210
   7348                                                          xxxxxxxxxxxxx111xxxx01100x10011x
   7349                                                          st1b.  */
   7350                                                       return 1815;
   7351                                                     }
   7352                                                   else
   7353                                                     {
   7354                                                       /* 33222222222211111111110000000000
   7355                                                          10987654321098765432109876543210
   7356                                                          xxxxxxxxxxxxx111xxxx01110x10011x
   7357                                                          st1h.  */
   7358                                                       return 1836;
   7359                                                     }
   7360                                                 }
   7361                                             }
   7362                                           else
   7363                                             {
   7364                                               if (((word >> 22) & 0x1) == 0)
   7365                                                 {
   7366                                                   if (((word >> 23) & 0x1) == 0)
   7367                                                     {
   7368                                                       /* 33222222222211111111110000000000
   7369                                                          10987654321098765432109876543210
   7370                                                          xxxxxxxxxxxxx111xxxx11000x10011x
   7371                                                          st2b.  */
   7372                                                       return 1850;
   7373                                                     }
   7374                                                   else
   7375                                                     {
   7376                                                       /* 33222222222211111111110000000000
   7377                                                          10987654321098765432109876543210
   7378                                                          xxxxxxxxxxxxx111xxxx11010x10011x
   7379                                                          st2h.  */
   7380                                                       return 1854;
   7381                                                     }
   7382                                                 }
   7383                                               else
   7384                                                 {
   7385                                                   if (((word >> 23) & 0x1) == 0)
   7386                                                     {
   7387                                                       /* 33222222222211111111110000000000
   7388                                                          10987654321098765432109876543210
   7389                                                          xxxxxxxxxxxxx111xxxx11100x10011x
   7390                                                          st4b.  */
   7391                                                       return 1866;
   7392                                                     }
   7393                                                   else
   7394                                                     {
   7395                                                       /* 33222222222211111111110000000000
   7396                                                          10987654321098765432109876543210
   7397                                                          xxxxxxxxxxxxx111xxxx11110x10011x
   7398                                                          st4h.  */
   7399                                                       return 1870;
   7400                                                     }
   7401                                                 }
   7402                                             }
   7403                                         }
   7404                                     }
   7405                                 }
   7406                             }
   7407                         }
   7408                     }
   7409                 }
   7410               else
   7411                 {
   7412                   if (((word >> 29) & 0x1) == 0)
   7413                     {
   7414                       if (((word >> 30) & 0x1) == 0)
   7415                         {
   7416                           if (((word >> 31) & 0x1) == 0)
   7417                             {
   7418                               if (((word >> 21) & 0x1) == 0)
   7419                                 {
   7420                                   if (((word >> 20) & 0x1) == 0)
   7421                                     {
   7422                                       if (((word >> 22) & 0x1) == 0)
   7423                                         {
   7424                                           if (((word >> 23) & 0x1) == 0)
   7425                                             {
   7426                                               /* 33222222222211111111110000000000
   7427                                                  10987654321098765432109876543210
   7428                                                  xxxxxxxxxxxxxxxxxxxx00001x100000
   7429                                                  orr.  */
   7430                                               return 1695;
   7431                                             }
   7432                                           else
   7433                                             {
   7434                                               /* 33222222222211111111110000000000
   7435                                                  10987654321098765432109876543210
   7436                                                  xxxxxxxxxxxxxxxxxxxx00011x100000
   7437                                                  and.  */
   7438                                               return 1239;
   7439                                             }
   7440                                         }
   7441                                       else
   7442                                         {
   7443                                           if (((word >> 23) & 0x1) == 0)
   7444                                             {
   7445                                               /* 33222222222211111111110000000000
   7446                                                  10987654321098765432109876543210
   7447                                                  xxxxxxxxxxxxxxxxxxxx00101x100000
   7448                                                  eor.  */
   7449                                               return 1326;
   7450                                             }
   7451                                           else
   7452                                             {
   7453                                               /* 33222222222211111111110000000000
   7454                                                  10987654321098765432109876543210
   7455                                                  xxxxxxxxxxxxxxxxxxxx00111x100000
   7456                                                  dupm.  */
   7457                                               return 1324;
   7458                                             }
   7459                                         }
   7460                                     }
   7461                                   else
   7462                                     {
   7463                                       if (((word >> 15) & 0x1) == 0)
   7464                                         {
   7465                                           /* 33222222222211111111110000000000
   7466                                              10987654321098765432109876543210
   7467                                              xxxxxxxxxxxxxxx0xxxx10xx1x100000
   7468                                              cpy.  */
   7469                                           return 1309;
   7470                                         }
   7471                                       else
   7472                                         {
   7473                                           /* 33222222222211111111110000000000
   7474                                              10987654321098765432109876543210
   7475                                              xxxxxxxxxxxxxxx1xxxx10xx1x100000
   7476                                              fcpy.  */
   7477                                           return 1356;
   7478                                         }
   7479                                     }
   7480                                 }
   7481                               else
   7482                                 {
   7483                                   if (((word >> 14) & 0x1) == 0)
   7484                                     {
   7485                                       if (((word >> 13) & 0x1) == 0)
   7486                                         {
   7487                                           if (((word >> 15) & 0x1) == 0)
   7488                                             {
   7489                                               /* 33222222222211111111110000000000
   7490                                                  10987654321098765432109876543210
   7491                                                  xxxxxxxxxxxxx000xxxxx1xx1x100000
   7492                                                  ext.  */
   7493                                               return 1331;
   7494                                             }
   7495                                           else
   7496                                             {
   7497                                               if (((word >> 16) & 0x1) == 0)
   7498                                                 {
   7499                                                   if (((word >> 17) & 0x1) == 0)
   7500                                                     {
   7501                                                       if (((word >> 18) & 0x1) == 0)
   7502                                                         {
   7503                                                           if (((word >> 19) & 0x1) == 0)
   7504                                                             {
   7505                                                               /* 33222222222211111111110000000000
   7506                                                                  10987654321098765432109876543210
   7507                                                                  xxxxxxxxxxxxx0010000x1xx1x100000
   7508                                                                  cpy.  */
   7509                                                               return 1307;
   7510                                                             }
   7511                                                           else
   7512                                                             {
   7513                                                               /* 33222222222211111111110000000000
   7514                                                                  10987654321098765432109876543210
   7515                                                                  xxxxxxxxxxxxx0010001x1xx1x100000
   7516                                                                  clasta.  */
   7517                                                               return 1265;
   7518                                                             }
   7519                                                         }
   7520                                                       else
   7521                                                         {
   7522                                                           if (((word >> 19) & 0x1) == 0)
   7523                                                             {
   7524                                                               /* 33222222222211111111110000000000
   7525                                                                  10987654321098765432109876543210
   7526                                                                  xxxxxxxxxxxxx0010010x1xx1x100000
   7527                                                                  revb.  */
   7528                                                               return 1743;
   7529                                                             }
   7530                                                           else
   7531                                                             {
   7532                                                               /* 33222222222211111111110000000000
   7533                                                                  10987654321098765432109876543210
   7534                                                                  xxxxxxxxxxxxx0010011x1xx1x100000
   7535                                                                  splice.  */
   7536                                                               return 1770;
   7537                                                             }
   7538                                                         }
   7539                                                     }
   7540                                                   else
   7541                                                     {
   7542                                                       if (((word >> 18) & 0x1) == 0)
   7543                                                         {
   7544                                                           if (((word >> 19) & 0x1) == 0)
   7545                                                             {
   7546                                                               /* 33222222222211111111110000000000
   7547                                                                  10987654321098765432109876543210
   7548                                                                  xxxxxxxxxxxxx0010100x1xx1x100000
   7549                                                                  lasta.  */
   7550                                                               return 1453;
   7551                                                             }
   7552                                                           else
   7553                                                             {
   7554                                                               /* 33222222222211111111110000000000
   7555                                                                  10987654321098765432109876543210
   7556                                                                  xxxxxxxxxxxxx0010101x1xx1x100000
   7557                                                                  clasta.  */
   7558                                                               return 1266;
   7559                                                             }
   7560                                                         }
   7561                                                       else
   7562                                                         {
   7563                                                           /* 33222222222211111111110000000000
   7564                                                              10987654321098765432109876543210
   7565                                                              xxxxxxxxxxxxx001011xx1xx1x100000
   7566                                                              revw.  */
   7567                                                           return 1745;
   7568                                                         }
   7569                                                     }
   7570                                                 }
   7571                                               else
   7572                                                 {
   7573                                                   if (((word >> 17) & 0x1) == 0)
   7574                                                     {
   7575                                                       if (((word >> 18) & 0x1) == 0)
   7576                                                         {
   7577                                                           if (((word >> 19) & 0x1) == 0)
   7578                                                             {
   7579                                                               /* 33222222222211111111110000000000
   7580                                                                  10987654321098765432109876543210
   7581                                                                  xxxxxxxxxxxxx0011000x1xx1x100000
   7582                                                                  compact.  */
   7583                                                               return 1306;
   7584                                                             }
   7585                                                           else
   7586                                                             {
   7587                                                               /* 33222222222211111111110000000000
   7588                                                                  10987654321098765432109876543210
   7589                                                                  xxxxxxxxxxxxx0011001x1xx1x100000
   7590                                                                  clastb.  */
   7591                                                               return 1268;
   7592                                                             }
   7593                                                         }
   7594                                                       else
   7595                                                         {
   7596                                                           /* 33222222222211111111110000000000
   7597                                                              10987654321098765432109876543210
   7598                                                              xxxxxxxxxxxxx001101xx1xx1x100000
   7599                                                              revh.  */
   7600                                                           return 1744;
   7601                                                         }
   7602                                                     }
   7603                                                   else
   7604                                                     {
   7605                                                       if (((word >> 18) & 0x1) == 0)
   7606                                                         {
   7607                                                           if (((word >> 19) & 0x1) == 0)
   7608                                                             {
   7609                                                               /* 33222222222211111111110000000000
   7610                                                                  10987654321098765432109876543210
   7611                                                                  xxxxxxxxxxxxx0011100x1xx1x100000
   7612                                                                  lastb.  */
   7613                                                               return 1455;
   7614                                                             }
   7615                                                           else
   7616                                                             {
   7617                                                               /* 33222222222211111111110000000000
   7618                                                                  10987654321098765432109876543210
   7619                                                                  xxxxxxxxxxxxx0011101x1xx1x100000
   7620                                                                  clastb.  */
   7621                                                               return 1269;
   7622                                                             }
   7623                                                         }
   7624                                                       else
   7625                                                         {
   7626                                                           /* 33222222222211111111110000000000
   7627                                                              10987654321098765432109876543210
   7628                                                              xxxxxxxxxxxxx001111xx1xx1x100000
   7629                                                              rbit.  */
   7630                                                           return 1736;
   7631                                                         }
   7632                                                     }
   7633                                                 }
   7634                                             }
   7635                                         }
   7636                                       else
   7637                                         {
   7638                                           if (((word >> 15) & 0x1) == 0)
   7639                                             {
   7640                                               if (((word >> 11) & 0x1) == 0)
   7641                                                 {
   7642                                                   if (((word >> 12) & 0x1) == 0)
   7643                                                     {
   7644                                                       /* 33222222222211111111110000000000
   7645                                                          10987654321098765432109876543210
   7646                                                          xxxxxxxxxxx00100xxxxx1xx1x100000
   7647                                                          dup.  */
   7648                                                       return 1322;
   7649                                                     }
   7650                                                   else
   7651                                                     {
   7652                                                       /* 33222222222211111111110000000000
   7653                                                          10987654321098765432109876543210
   7654                                                          xxxxxxxxxxx01100xxxxx1xx1x100000
   7655                                                          tbl.  */
   7656                                                       return 1893;
   7657                                                     }
   7658                                                 }
   7659                                               else
   7660                                                 {
   7661                                                   if (((word >> 16) & 0x1) == 0)
   7662                                                     {
   7663                                                       if (((word >> 17) & 0x1) == 0)
   7664                                                         {
   7665                                                           if (((word >> 18) & 0x1) == 0)
   7666                                                             {
   7667                                                               if (((word >> 19) & 0x1) == 0)
   7668                                                                 {
   7669                                                                   if (((word >> 20) & 0x1) == 0)
   7670                                                                     {
   7671                                                                       /* 33222222222211111111110000000000
   7672                                                                          10987654321098765432109876543210
   7673                                                                          xxxxxxxxxxx1x100000001xx1x100000
   7674                                                                          dup.  */
   7675                                                                       return 1321;
   7676                                                                     }
   7677                                                                   else
   7678                                                                     {
   7679                                                                       /* 33222222222211111111110000000000
   7680                                                                          10987654321098765432109876543210
   7681                                                                          xxxxxxxxxxx1x100000011xx1x100000
   7682                                                                          sunpklo.  */
   7683                                                                       return 1889;
   7684                                                                     }
   7685                                                                 }
   7686                                                               else
   7687                                                                 {
   7688                                                                   /* 33222222222211111111110000000000
   7689                                                                      10987654321098765432109876543210
   7690                                                                      xxxxxxxxxxx1x1000001x1xx1x100000
   7691                                                                      rev.  */
   7692                                                                   return 1742;
   7693                                                                 }
   7694                                                             }
   7695                                                           else
   7696                                                             {
   7697                                                               if (((word >> 20) & 0x1) == 0)
   7698                                                                 {
   7699                                                                   /* 33222222222211111111110000000000
   7700                                                                      10987654321098765432109876543210
   7701                                                                      xxxxxxxxxxx1x100001x01xx1x100000
   7702                                                                      insr.  */
   7703                                                                   return 1450;
   7704                                                                 }
   7705                                                               else
   7706                                                                 {
   7707                                                                   /* 33222222222211111111110000000000
   7708                                                                      10987654321098765432109876543210
   7709                                                                      xxxxxxxxxxx1x100001x11xx1x100000
   7710                                                                      insr.  */
   7711                                                                   return 1451;
   7712                                                                 }
   7713                                                             }
   7714                                                         }
   7715                                                       else
   7716                                                         {
   7717                                                           /* 33222222222211111111110000000000
   7718                                                              10987654321098765432109876543210
   7719                                                              xxxxxxxxxxx1x10001xxx1xx1x100000
   7720                                                              uunpklo.  */
   7721                                                           return 1952;
   7722                                                         }
   7723                                                     }
   7724                                                   else
   7725                                                     {
   7726                                                       if (((word >> 17) & 0x1) == 0)
   7727                                                         {
   7728                                                           /* 33222222222211111111110000000000
   7729                                                              10987654321098765432109876543210
   7730                                                              xxxxxxxxxxx1x10010xxx1xx1x100000
   7731                                                              sunpkhi.  */
   7732                                                           return 1888;
   7733                                                         }
   7734                                                       else
   7735                                                         {
   7736                                                           /* 33222222222211111111110000000000
   7737                                                              10987654321098765432109876543210
   7738                                                              xxxxxxxxxxx1x10011xxx1xx1x100000
   7739                                                              uunpkhi.  */
   7740                                                           return 1951;
   7741                                                         }
   7742                                                     }
   7743                                                 }
   7744                                             }
   7745                                           else
   7746                                             {
   7747                                               if (((word >> 16) & 0x1) == 0)
   7748                                                 {
   7749                                                   if (((word >> 19) & 0x1) == 0)
   7750                                                     {
   7751                                                       if (((word >> 20) & 0x1) == 0)
   7752                                                         {
   7753                                                           /* 33222222222211111111110000000000
   7754                                                              10987654321098765432109876543210
   7755                                                              xxxxxxxxxxxxx1010xx001xx1x100000
   7756                                                              lasta.  */
   7757                                                           return 1452;
   7758                                                         }
   7759                                                       else
   7760                                                         {
   7761                                                           /* 33222222222211111111110000000000
   7762                                                              10987654321098765432109876543210
   7763                                                              xxxxxxxxxxxxx1010xx011xx1x100000
   7764                                                              clasta.  */
   7765                                                           return 1267;
   7766                                                         }
   7767                                                     }
   7768                                                   else
   7769                                                     {
   7770                                                       /* 33222222222211111111110000000000
   7771                                                          10987654321098765432109876543210
   7772                                                          xxxxxxxxxxxxx1010xx1x1xx1x100000
   7773                                                          cpy.  */
   7774                                                       return 1308;
   7775                                                     }
   7776                                                 }
   7777                                               else
   7778                                                 {
   7779                                                   if (((word >> 20) & 0x1) == 0)
   7780                                                     {
   7781                                                       /* 33222222222211111111110000000000
   7782                                                          10987654321098765432109876543210
   7783                                                          xxxxxxxxxxxxx1011xxx01xx1x100000
   7784                                                          lastb.  */
   7785                                                       return 1454;
   7786                                                     }
   7787                                                   else
   7788                                                     {
   7789                                                       /* 33222222222211111111110000000000
   7790                                                          10987654321098765432109876543210
   7791                                                          xxxxxxxxxxxxx1011xxx11xx1x100000
   7792                                                          clastb.  */
   7793                                                       return 1270;
   7794                                                     }
   7795                                                 }
   7796                                             }
   7797                                         }
   7798                                     }
   7799                                   else
   7800                                     {
   7801                                       if (((word >> 15) & 0x1) == 0)
   7802                                         {
   7803                                           if (((word >> 10) & 0x1) == 0)
   7804                                             {
   7805                                               if (((word >> 11) & 0x1) == 0)
   7806                                                 {
   7807                                                   if (((word >> 12) & 0x1) == 0)
   7808                                                     {
   7809                                                       if (((word >> 13) & 0x1) == 0)
   7810                                                         {
   7811                                                           if (((word >> 20) & 0x1) == 0)
   7812                                                             {
   7813                                                               /* 33222222222211111111110000000000
   7814                                                                  10987654321098765432109876543210
   7815                                                                  xxxxxxxxxx000010xxxx01xx1x100000
   7816                                                                  zip1.  */
   7817                                                               return 1969;
   7818                                                             }
   7819                                                           else
   7820                                                             {
   7821                                                               if (((word >> 16) & 0x1) == 0)
   7822                                                                 {
   7823                                                                   if (((word >> 18) & 0x1) == 0)
   7824                                                                     {
   7825                                                                       /* 33222222222211111111110000000000
   7826                                                                          10987654321098765432109876543210
   7827                                                                          xxxxxxxxxx0000100x0x11xx1x100000
   7828                                                                          punpklo.  */
   7829                                                                       return 1735;
   7830                                                                     }
   7831                                                                   else
   7832                                                                     {
   7833                                                                       /* 33222222222211111111110000000000
   7834                                                                          10987654321098765432109876543210
   7835                                                                          xxxxxxxxxx0000100x1x11xx1x100000
   7836                                                                          rev.  */
   7837                                                                       return 1741;
   7838                                                                     }
   7839                                                                 }
   7840                                                               else
   7841                                                                 {
   7842                                                                   /* 33222222222211111111110000000000
   7843                                                                      10987654321098765432109876543210
   7844                                                                      xxxxxxxxxx0000101xxx11xx1x100000
   7845                                                                      punpkhi.  */
   7846                                                                   return 1734;
   7847                                                                 }
   7848                                                             }
   7849                                                         }
   7850                                                       else
   7851                                                         {
   7852                                                           /* 33222222222211111111110000000000
   7853                                                              10987654321098765432109876543210
   7854                                                              xxxxxxxxxx000110xxxxx1xx1x100000
   7855                                                              zip1.  */
   7856                                                           return 1970;
   7857                                                         }
   7858                                                     }
   7859                                                   else
   7860                                                     {
   7861                                                       if (((word >> 13) & 0x1) == 0)
   7862                                                         {
   7863                                                           /* 33222222222211111111110000000000
   7864                                                              10987654321098765432109876543210
   7865                                                              xxxxxxxxxx001010xxxxx1xx1x100000
   7866                                                              trn1.  */
   7867                                                           return 1894;
   7868                                                         }
   7869                                                       else
   7870                                                         {
   7871                                                           /* 33222222222211111111110000000000
   7872                                                              10987654321098765432109876543210
   7873                                                              xxxxxxxxxx001110xxxxx1xx1x100000
   7874                                                              trn1.  */
   7875                                                           return 1895;
   7876                                                         }
   7877                                                     }
   7878                                                 }
   7879                                               else
   7880                                                 {
   7881                                                   if (((word >> 13) & 0x1) == 0)
   7882                                                     {
   7883                                                       /* 33222222222211111111110000000000
   7884                                                          10987654321098765432109876543210
   7885                                                          xxxxxxxxxx01x010xxxxx1xx1x100000
   7886                                                          uzp1.  */
   7887                                                       return 1956;
   7888                                                     }
   7889                                                   else
   7890                                                     {
   7891                                                       /* 33222222222211111111110000000000
   7892                                                          10987654321098765432109876543210
   7893                                                          xxxxxxxxxx01x110xxxxx1xx1x100000
   7894                                                          uzp1.  */
   7895                                                       return 1957;
   7896                                                     }
   7897                                                 }
   7898                                             }
   7899                                           else
   7900                                             {
   7901                                               if (((word >> 11) & 0x1) == 0)
   7902                                                 {
   7903                                                   if (((word >> 12) & 0x1) == 0)
   7904                                                     {
   7905                                                       if (((word >> 13) & 0x1) == 0)
   7906                                                         {
   7907                                                           /* 33222222222211111111110000000000
   7908                                                              10987654321098765432109876543210
   7909                                                              xxxxxxxxxx100010xxxxx1xx1x100000
   7910                                                              zip2.  */
   7911                                                           return 1971;
   7912                                                         }
   7913                                                       else
   7914                                                         {
   7915                                                           /* 33222222222211111111110000000000
   7916                                                              10987654321098765432109876543210
   7917                                                              xxxxxxxxxx100110xxxxx1xx1x100000
   7918                                                              zip2.  */
   7919                                                           return 1972;
   7920                                                         }
   7921                                                     }
   7922                                                   else
   7923                                                     {
   7924                                                       if (((word >> 13) & 0x1) == 0)
   7925                                                         {
   7926                                                           /* 33222222222211111111110000000000
   7927                                                              10987654321098765432109876543210
   7928                                                              xxxxxxxxxx101010xxxxx1xx1x100000
   7929                                                              trn2.  */
   7930                                                           return 1896;
   7931                                                         }
   7932                                                       else
   7933                                                         {
   7934                                                           /* 33222222222211111111110000000000
   7935                                                              10987654321098765432109876543210
   7936                                                              xxxxxxxxxx101110xxxxx1xx1x100000
   7937                                                              trn2.  */
   7938                                                           return 1897;
   7939                                                         }
   7940                                                     }
   7941                                                 }
   7942                                               else
   7943                                                 {
   7944                                                   if (((word >> 13) & 0x1) == 0)
   7945                                                     {
   7946                                                       /* 33222222222211111111110000000000
   7947                                                          10987654321098765432109876543210
   7948                                                          xxxxxxxxxx11x010xxxxx1xx1x100000
   7949                                                          uzp2.  */
   7950                                                       return 1958;
   7951                                                     }
   7952                                                   else
   7953                                                     {
   7954                                                       /* 33222222222211111111110000000000
   7955                                                          10987654321098765432109876543210
   7956                                                          xxxxxxxxxx11x110xxxxx1xx1x100000
   7957                                                          uzp2.  */
   7958                                                       return 1959;
   7959                                                     }
   7960                                                 }
   7961                                             }
   7962                                         }
   7963                                       else
   7964                                         {
   7965                                           /* 33222222222211111111110000000000
   7966                                              10987654321098765432109876543210
   7967                                              xxxxxxxxxxxxxx11xxxxx1xx1x100000
   7968                                              sel.  */
   7969                                           return 1760;
   7970                                         }
   7971                                     }
   7972                                 }
   7973                             }
   7974                           else
   7975                             {
   7976                               if (((word >> 13) & 0x1) == 0)
   7977                                 {
   7978                                   if (((word >> 14) & 0x1) == 0)
   7979                                     {
   7980                                       if (((word >> 15) & 0x1) == 0)
   7981                                         {
   7982                                           if (((word >> 22) & 0x1) == 0)
   7983                                             {
   7984                                               /* 33222222222211111111110000000000
   7985                                                  10987654321098765432109876543210
   7986                                                  xxxxxxxxxxxxx000xxxxxx0x1x100001
   7987                                                  ldr.  */
   7988                                               return 1664;
   7989                                             }
   7990                                           else
   7991                                             {
   7992                                               /* 33222222222211111111110000000000
   7993                                                  10987654321098765432109876543210
   7994                                                  xxxxxxxxxxxxx000xxxxxx1x1x100001
   7995                                                  prfb.  */
   7996                                               return 1708;
   7997                                             }
   7998                                         }
   7999                                       else
   8000                                         {
   8001                                           if (((word >> 23) & 0x1) == 0)
   8002                                             {
   8003                                               /* 33222222222211111111110000000000
   8004                                                  10987654321098765432109876543210
   8005                                                  xxxxxxxxxxxxx001xxxxxxx01x100001
   8006                                                  ld1rsh.  */
   8007                                               return 1509;
   8008                                             }
   8009                                           else
   8010                                             {
   8011                                               /* 33222222222211111111110000000000
   8012                                                  10987654321098765432109876543210
   8013                                                  xxxxxxxxxxxxx001xxxxxxx11x100001
   8014                                                  ld1rsb.  */
   8015                                               return 1506;
   8016                                             }
   8017                                         }
   8018                                     }
   8019                                   else
   8020                                     {
   8021                                       if (((word >> 15) & 0x1) == 0)
   8022                                         {
   8023                                           if (((word >> 23) & 0x1) == 0)
   8024                                             {
   8025                                               if (((word >> 21) & 0x1) == 0)
   8026                                                 {
   8027                                                   /* 33222222222211111111110000000000
   8028                                                      10987654321098765432109876543210
   8029                                                      xxxxxxxxxxxxx010xxxxx0x01x100001
   8030                                                      ld1w.  */
   8031                                                   return 1544;
   8032                                                 }
   8033                                               else
   8034                                                 {
   8035                                                   /* 33222222222211111111110000000000
   8036                                                      10987654321098765432109876543210
   8037                                                      xxxxxxxxxxxxx010xxxxx1x01x100001
   8038                                                      ld1w.  */
   8039                                                   return 1545;
   8040                                                 }
   8041                                             }
   8042                                           else
   8043                                             {
   8044                                               if (((word >> 22) & 0x1) == 0)
   8045                                                 {
   8046                                                   /* 33222222222211111111110000000000
   8047                                                      10987654321098765432109876543210
   8048                                                      xxxxxxxxxxxxx010xxxxxx011x100001
   8049                                                      ldr.  */
   8050                                                   return 1665;
   8051                                                 }
   8052                                               else
   8053                                                 {
   8054                                                   /* 33222222222211111111110000000000
   8055                                                      10987654321098765432109876543210
   8056                                                      xxxxxxxxxxxxx010xxxxxx111x100001
   8057                                                      prfw.  */
   8058                                                   return 1729;
   8059                                                 }
   8060                                             }
   8061                                         }
   8062                                       else
   8063                                         {
   8064                                           if (((word >> 22) & 0x1) == 0)
   8065                                             {
   8066                                               if (((word >> 21) & 0x1) == 0)
   8067                                                 {
   8068                                                   if (((word >> 23) & 0x1) == 0)
   8069                                                     {
   8070                                                       /* 33222222222211111111110000000000
   8071                                                          10987654321098765432109876543210
   8072                                                          xxxxxxxxxxxxx011xxxxx0001x100001
   8073                                                          prfw.  */
   8074                                                       return 1725;
   8075                                                     }
   8076                                                   else
   8077                                                     {
   8078                                                       /* 33222222222211111111110000000000
   8079                                                          10987654321098765432109876543210
   8080                                                          xxxxxxxxxxxxx011xxxxx0011x100001
   8081                                                          prfd.  */
   8082                                                       return 1711;
   8083                                                     }
   8084                                                 }
   8085                                               else
   8086                                                 {
   8087                                                   /* 33222222222211111111110000000000
   8088                                                      10987654321098765432109876543210
   8089                                                      xxxxxxxxxxxxx011xxxxx10x1x100001
   8090                                                      ld1w.  */
   8091                                                   return 1552;
   8092                                                 }
   8093                                             }
   8094                                           else
   8095                                             {
   8096                                               if (((word >> 23) & 0x1) == 0)
   8097                                                 {
   8098                                                   /* 33222222222211111111110000000000
   8099                                                      10987654321098765432109876543210
   8100                                                      xxxxxxxxxxxxx011xxxxxx101x100001
   8101                                                      ld1rw.  */
   8102                                                   return 1512;
   8103                                                 }
   8104                                               else
   8105                                                 {
   8106                                                   /* 33222222222211111111110000000000
   8107                                                      10987654321098765432109876543210
   8108                                                      xxxxxxxxxxxxx011xxxxxx111x100001
   8109                                                      ld1rsb.  */
   8110                                                   return 1508;
   8111                                                 }
   8112                                             }
   8113                                         }
   8114                                     }
   8115                                 }
   8116                               else
   8117                                 {
   8118                                   if (((word >> 14) & 0x1) == 0)
   8119                                     {
   8120                                       if (((word >> 15) & 0x1) == 0)
   8121                                         {
   8122                                           /* 33222222222211111111110000000000
   8123                                              10987654321098765432109876543210
   8124                                              xxxxxxxxxxxxx100xxxxxxxx1x100001
   8125                                              prfh.  */
   8126                                           return 1722;
   8127                                         }
   8128                                       else
   8129                                         {
   8130                                           if (((word >> 23) & 0x1) == 0)
   8131                                             {
   8132                                               /* 33222222222211111111110000000000
   8133                                                  10987654321098765432109876543210
   8134                                                  xxxxxxxxxxxxx101xxxxxxx01x100001
   8135                                                  ld1rsh.  */
   8136                                               return 1510;
   8137                                             }
   8138                                           else
   8139                                             {
   8140                                               /* 33222222222211111111110000000000
   8141                                                  10987654321098765432109876543210
   8142                                                  xxxxxxxxxxxxx101xxxxxxx11x100001
   8143                                                  ld1rsb.  */
   8144                                               return 1507;
   8145                                             }
   8146                                         }
   8147                                     }
   8148                                   else
   8149                                     {
   8150                                       if (((word >> 15) & 0x1) == 0)
   8151                                         {
   8152                                           if (((word >> 23) & 0x1) == 0)
   8153                                             {
   8154                                               if (((word >> 21) & 0x1) == 0)
   8155                                                 {
   8156                                                   /* 33222222222211111111110000000000
   8157                                                      10987654321098765432109876543210
   8158                                                      xxxxxxxxxxxxx110xxxxx0x01x100001
   8159                                                      ldff1w.  */
   8160                                                   return 1630;
   8161                                                 }
   8162                                               else
   8163                                                 {
   8164                                                   /* 33222222222211111111110000000000
   8165                                                      10987654321098765432109876543210
   8166                                                      xxxxxxxxxxxxx110xxxxx1x01x100001
   8167                                                      ldff1w.  */
   8168                                                   return 1631;
   8169                                                 }
   8170                                             }
   8171                                           else
   8172                                             {
   8173                                               /* 33222222222211111111110000000000
   8174                                                  10987654321098765432109876543210
   8175                                                  xxxxxxxxxxxxx110xxxxxxx11x100001
   8176                                                  prfd.  */
   8177                                               return 1715;
   8178                                             }
   8179                                         }
   8180                                       else
   8181                                         {
   8182                                           if (((word >> 22) & 0x1) == 0)
   8183                                             {
   8184                                               if (((word >> 21) & 0x1) == 0)
   8185                                                 {
   8186                                                   if (((word >> 23) & 0x1) == 0)
   8187                                                     {
   8188                                                       /* 33222222222211111111110000000000
   8189                                                          10987654321098765432109876543210
   8190                                                          xxxxxxxxxxxxx111xxxxx0001x100001
   8191                                                          prfw.  */
   8192                                                       return 1728;
   8193                                                     }
   8194                                                   else
   8195                                                     {
   8196                                                       /* 33222222222211111111110000000000
   8197                                                          10987654321098765432109876543210
   8198                                                          xxxxxxxxxxxxx111xxxxx0011x100001
   8199                                                          prfd.  */
   8200                                                       return 1714;
   8201                                                     }
   8202                                                 }
   8203                                               else
   8204                                                 {
   8205                                                   /* 33222222222211111111110000000000
   8206                                                      10987654321098765432109876543210
   8207                                                      xxxxxxxxxxxxx111xxxxx10x1x100001
   8208                                                      ldff1w.  */
   8209                                                   return 1638;
   8210                                                 }
   8211                                             }
   8212                                           else
   8213                                             {
   8214                                               if (((word >> 23) & 0x1) == 0)
   8215                                                 {
   8216                                                   /* 33222222222211111111110000000000
   8217                                                      10987654321098765432109876543210
   8218                                                      xxxxxxxxxxxxx111xxxxxx101x100001
   8219                                                      ld1rw.  */
   8220                                                   return 1513;
   8221                                                 }
   8222                                               else
   8223                                                 {
   8224                                                   /* 33222222222211111111110000000000
   8225                                                      10987654321098765432109876543210
   8226                                                      xxxxxxxxxxxxx111xxxxxx111x100001
   8227                                                      ld1rd.  */
   8228                                                   return 1494;
   8229                                                 }
   8230                                             }
   8231                                         }
   8232                                     }
   8233                                 }
   8234                             }
   8235                         }
   8236                       else
   8237                         {
   8238                           if (((word >> 13) & 0x1) == 0)
   8239                             {
   8240                               if (((word >> 14) & 0x1) == 0)
   8241                                 {
   8242                                   if (((word >> 15) & 0x1) == 0)
   8243                                     {
   8244                                       if (((word >> 21) & 0x1) == 0)
   8245                                         {
   8246                                           /* 33222222222211111111110000000000
   8247                                              10987654321098765432109876543210
   8248                                              xxxxxxxxxxxxx000xxxxx0xx1x10001x
   8249                                              ld1sw.  */
   8250                                           return 1538;
   8251                                         }
   8252                                       else
   8253                                         {
   8254                                           /* 33222222222211111111110000000000
   8255                                              10987654321098765432109876543210
   8256                                              xxxxxxxxxxxxx000xxxxx1xx1x10001x
   8257                                              ld1sw.  */
   8258                                           return 1539;
   8259                                         }
   8260                                     }
   8261                                   else
   8262                                     {
   8263                                       if (((word >> 21) & 0x1) == 0)
   8264                                         {
   8265                                           /* 33222222222211111111110000000000
   8266                                              10987654321098765432109876543210
   8267                                              xxxxxxxxxxxxx001xxxxx0xx1x10001x
   8268                                              ld1sw.  */
   8269                                           return 1540;
   8270                                         }
   8271                                       else
   8272                                         {
   8273                                           if (((word >> 22) & 0x1) == 0)
   8274                                             {
   8275                                               /* 33222222222211111111110000000000
   8276                                                  10987654321098765432109876543210
   8277                                                  xxxxxxxxxxxxx001xxxxx10x1x10001x
   8278                                                  ld1sw.  */
   8279                                               return 1543;
   8280                                             }
   8281                                           else
   8282                                             {
   8283                                               /* 33222222222211111111110000000000
   8284                                                  10987654321098765432109876543210
   8285                                                  xxxxxxxxxxxxx001xxxxx11x1x10001x
   8286                                                  ld1sw.  */
   8287                                               return 1541;
   8288                                             }
   8289                                         }
   8290                                     }
   8291                                 }
   8292                               else
   8293                                 {
   8294                                   if (((word >> 15) & 0x1) == 0)
   8295                                     {
   8296                                       if (((word >> 21) & 0x1) == 0)
   8297                                         {
   8298                                           if (((word >> 23) & 0x1) == 0)
   8299                                             {
   8300                                               /* 33222222222211111111110000000000
   8301                                                  10987654321098765432109876543210
   8302                                                  xxxxxxxxxxxxx010xxxxx0x01x10001x
   8303                                                  ld1w.  */
   8304                                               return 1548;
   8305                                             }
   8306                                           else
   8307                                             {
   8308                                               /* 33222222222211111111110000000000
   8309                                                  10987654321098765432109876543210
   8310                                                  xxxxxxxxxxxxx010xxxxx0x11x10001x
   8311                                                  ld1d.  */
   8312                                               return 1470;
   8313                                             }
   8314                                         }
   8315                                       else
   8316                                         {
   8317                                           if (((word >> 23) & 0x1) == 0)
   8318                                             {
   8319                                               /* 33222222222211111111110000000000
   8320                                                  10987654321098765432109876543210
   8321                                                  xxxxxxxxxxxxx010xxxxx1x01x10001x
   8322                                                  ld1w.  */
   8323                                               return 1549;
   8324                                             }
   8325                                           else
   8326                                             {
   8327                                               /* 33222222222211111111110000000000
   8328                                                  10987654321098765432109876543210
   8329                                                  xxxxxxxxxxxxx010xxxxx1x11x10001x
   8330                                                  ld1d.  */
   8331                                               return 1471;
   8332                                             }
   8333                                         }
   8334                                     }
   8335                                   else
   8336                                     {
   8337                                       if (((word >> 21) & 0x1) == 0)
   8338                                         {
   8339                                           if (((word >> 23) & 0x1) == 0)
   8340                                             {
   8341                                               /* 33222222222211111111110000000000
   8342                                                  10987654321098765432109876543210
   8343                                                  xxxxxxxxxxxxx011xxxxx0x01x10001x
   8344                                                  ld1w.  */
   8345                                               return 1550;
   8346                                             }
   8347                                           else
   8348                                             {
   8349                                               /* 33222222222211111111110000000000
   8350                                                  10987654321098765432109876543210
   8351                                                  xxxxxxxxxxxxx011xxxxx0x11x10001x
   8352                                                  ld1d.  */
   8353                                               return 1472;
   8354                                             }
   8355                                         }
   8356                                       else
   8357                                         {
   8358                                           if (((word >> 22) & 0x1) == 0)
   8359                                             {
   8360                                               if (((word >> 23) & 0x1) == 0)
   8361                                                 {
   8362                                                   /* 33222222222211111111110000000000
   8363                                                      10987654321098765432109876543210
   8364                                                      xxxxxxxxxxxxx011xxxxx1001x10001x
   8365                                                      ld1w.  */
   8366                                                   return 1555;
   8367                                                 }
   8368                                               else
   8369                                                 {
   8370                                                   /* 33222222222211111111110000000000
   8371                                                      10987654321098765432109876543210
   8372                                                      xxxxxxxxxxxxx011xxxxx1011x10001x
   8373                                                      ld1d.  */
   8374                                                   return 1475;
   8375                                                 }
   8376                                             }
   8377                                           else
   8378                                             {
   8379                                               if (((word >> 23) & 0x1) == 0)
   8380                                                 {
   8381                                                   /* 33222222222211111111110000000000
   8382                                                      10987654321098765432109876543210
   8383                                                      xxxxxxxxxxxxx011xxxxx1101x10001x
   8384                                                      ld1w.  */
   8385                                                   return 1551;
   8386                                                 }
   8387                                               else
   8388                                                 {
   8389                                                   /* 33222222222211111111110000000000
   8390                                                      10987654321098765432109876543210
   8391                                                      xxxxxxxxxxxxx011xxxxx1111x10001x
   8392                                                      ld1d.  */
   8393                                                   return 1473;
   8394                                                 }
   8395                                             }
   8396                                         }
   8397                                     }
   8398                                 }
   8399                             }
   8400                           else
   8401                             {
   8402                               if (((word >> 14) & 0x1) == 0)
   8403                                 {
   8404                                   if (((word >> 15) & 0x1) == 0)
   8405                                     {
   8406                                       if (((word >> 21) & 0x1) == 0)
   8407                                         {
   8408                                           /* 33222222222211111111110000000000
   8409                                              10987654321098765432109876543210
   8410                                              xxxxxxxxxxxxx100xxxxx0xx1x10001x
   8411                                              ldff1sw.  */
   8412                                           return 1625;
   8413                                         }
   8414                                       else
   8415                                         {
   8416                                           /* 33222222222211111111110000000000
   8417                                              10987654321098765432109876543210
   8418                                              xxxxxxxxxxxxx100xxxxx1xx1x10001x
   8419                                              ldff1sw.  */
   8420                                           return 1626;
   8421                                         }
   8422                                     }
   8423                                   else
   8424                                     {
   8425                                       if (((word >> 21) & 0x1) == 0)
   8426                                         {
   8427                                           /* 33222222222211111111110000000000
   8428                                              10987654321098765432109876543210
   8429                                              xxxxxxxxxxxxx101xxxxx0xx1x10001x
   8430                                              ldff1sw.  */
   8431                                           return 1627;
   8432                                         }
   8433                                       else
   8434                                         {
   8435                                           if (((word >> 22) & 0x1) == 0)
   8436                                             {
   8437                                               /* 33222222222211111111110000000000
   8438                                                  10987654321098765432109876543210
   8439                                                  xxxxxxxxxxxxx101xxxxx10x1x10001x
   8440                                                  ldff1sw.  */
   8441                                               return 1629;
   8442                                             }
   8443                                           else
   8444                                             {
   8445                                               /* 33222222222211111111110000000000
   8446                                                  10987654321098765432109876543210
   8447                                                  xxxxxxxxxxxxx101xxxxx11x1x10001x
   8448                                                  ldff1sw.  */
   8449                                               return 1628;
   8450                                             }
   8451                                         }
   8452                                     }
   8453                                 }
   8454                               else
   8455                                 {
   8456                                   if (((word >> 15) & 0x1) == 0)
   8457                                     {
   8458                                       if (((word >> 21) & 0x1) == 0)
   8459                                         {
   8460                                           if (((word >> 23) & 0x1) == 0)
   8461                                             {
   8462                                               /* 33222222222211111111110000000000
   8463                                                  10987654321098765432109876543210
   8464                                                  xxxxxxxxxxxxx110xxxxx0x01x10001x
   8465                                                  ldff1w.  */
   8466                                               return 1634;
   8467                                             }
   8468                                           else
   8469                                             {
   8470                                               /* 33222222222211111111110000000000
   8471                                                  10987654321098765432109876543210
   8472                                                  xxxxxxxxxxxxx110xxxxx0x11x10001x
   8473                                                  ldff1d.  */
   8474                                               return 1590;
   8475                                             }
   8476                                         }
   8477                                       else
   8478                                         {
   8479                                           if (((word >> 23) & 0x1) == 0)
   8480                                             {
   8481                                               /* 33222222222211111111110000000000
   8482                                                  10987654321098765432109876543210
   8483                                                  xxxxxxxxxxxxx110xxxxx1x01x10001x
   8484                                                  ldff1w.  */
   8485                                               return 1635;
   8486                                             }
   8487                                           else
   8488                                             {
   8489                                               /* 33222222222211111111110000000000
   8490                                                  10987654321098765432109876543210
   8491                                                  xxxxxxxxxxxxx110xxxxx1x11x10001x
   8492                                                  ldff1d.  */
   8493                                               return 1591;
   8494                                             }
   8495                                         }
   8496                                     }
   8497                                   else
   8498                                     {
   8499                                       if (((word >> 21) & 0x1) == 0)
   8500                                         {
   8501                                           if (((word >> 22) & 0x1) == 0)
   8502                                             {
   8503                                               if (((word >> 23) & 0x1) == 0)
   8504                                                 {
   8505                                                   /* 33222222222211111111110000000000
   8506                                                      10987654321098765432109876543210
   8507                                                      xxxxxxxxxxxxx111xxxxx0001x10001x
   8508                                                      prfw.  */
   8509                                                   return 1730;
   8510                                                 }
   8511                                               else
   8512                                                 {
   8513                                                   /* 33222222222211111111110000000000
   8514                                                      10987654321098765432109876543210
   8515                                                      xxxxxxxxxxxxx111xxxxx0011x10001x
   8516                                                      prfd.  */
   8517                                                   return 1716;
   8518                                                 }
   8519                                             }
   8520                                           else
   8521                                             {
   8522                                               if (((word >> 23) & 0x1) == 0)
   8523                                                 {
   8524                                                   /* 33222222222211111111110000000000
   8525                                                      10987654321098765432109876543210
   8526                                                      xxxxxxxxxxxxx111xxxxx0101x10001x
   8527                                                      ldff1w.  */
   8528                                                   return 1636;
   8529                                                 }
   8530                                               else
   8531                                                 {
   8532                                                   /* 33222222222211111111110000000000
   8533                                                      10987654321098765432109876543210
   8534                                                      xxxxxxxxxxxxx111xxxxx0111x10001x
   8535                                                      ldff1d.  */
   8536                                                   return 1592;
   8537                                                 }
   8538                                             }
   8539                                         }
   8540                                       else
   8541                                         {
   8542                                           if (((word >> 22) & 0x1) == 0)
   8543                                             {
   8544                                               if (((word >> 23) & 0x1) == 0)
   8545                                                 {
   8546                                                   /* 33222222222211111111110000000000
   8547                                                      10987654321098765432109876543210
   8548                                                      xxxxxxxxxxxxx111xxxxx1001x10001x
   8549                                                      ldff1w.  */
   8550                                                   return 1639;
   8551                                                 }
   8552                                               else
   8553                                                 {
   8554                                                   /* 33222222222211111111110000000000
   8555                                                      10987654321098765432109876543210
   8556                                                      xxxxxxxxxxxxx111xxxxx1011x10001x
   8557                                                      ldff1d.  */
   8558                                                   return 1594;
   8559                                                 }
   8560                                             }
   8561                                           else
   8562                                             {
   8563                                               if (((word >> 23) & 0x1) == 0)
   8564                                                 {
   8565                                                   /* 33222222222211111111110000000000
   8566                                                      10987654321098765432109876543210
   8567                                                      xxxxxxxxxxxxx111xxxxx1101x10001x
   8568                                                      ldff1w.  */
   8569                                                   return 1637;
   8570                                                 }
   8571                                               else
   8572                                                 {
   8573                                                   /* 33222222222211111111110000000000
   8574                                                      10987654321098765432109876543210
   8575                                                      xxxxxxxxxxxxx111xxxxx1111x10001x
   8576                                                      ldff1d.  */
   8577                                                   return 1593;
   8578                                                 }
   8579                                             }
   8580                                         }
   8581                                     }
   8582                                 }
   8583                             }
   8584                         }
   8585                     }
   8586                   else
   8587                     {
   8588                       if (((word >> 15) & 0x1) == 0)
   8589                         {
   8590                           if (((word >> 14) & 0x1) == 0)
   8591                             {
   8592                               if (((word >> 13) & 0x1) == 0)
   8593                                 {
   8594                                   if (((word >> 30) & 0x1) == 0)
   8595                                     {
   8596                                       if (((word >> 21) & 0x1) == 0)
   8597                                         {
   8598                                           if (((word >> 31) & 0x1) == 0)
   8599                                             {
   8600                                               if (((word >> 4) & 0x1) == 0)
   8601                                                 {
   8602                                                   /* 33222222222211111111110000000000
   8603                                                      10987654321098765432109876543210
   8604                                                      xxxx0xxxxxxxx000xxxxx0xx1x100100
   8605                                                      cmpge.  */
   8606                                                   return 1278;
   8607                                                 }
   8608                                               else
   8609                                                 {
   8610                                                   /* 33222222222211111111110000000000
   8611                                                      10987654321098765432109876543210
   8612                                                      xxxx1xxxxxxxx000xxxxx0xx1x100100
   8613                                                      cmpgt.  */
   8614                                                   return 1281;
   8615                                                 }
   8616                                             }
   8617                                           else
   8618                                             {
   8619                                               if (((word >> 23) & 0x1) == 0)
   8620                                                 {
   8621                                                   /* 33222222222211111111110000000000
   8622                                                      10987654321098765432109876543210
   8623                                                      xxxxxxxxxxxxx000xxxxx0x01x100101
   8624                                                      ld1rqw.  */
   8625                                                   return 1505;
   8626                                                 }
   8627                                               else
   8628                                                 {
   8629                                                   /* 33222222222211111111110000000000
   8630                                                      10987654321098765432109876543210
   8631                                                      xxxxxxxxxxxxx000xxxxx0x11x100101
   8632                                                      ld1rqd.  */
   8633                                                   return 1501;
   8634                                                 }
   8635                                             }
   8636                                         }
   8637                                       else
   8638                                         {
   8639                                           if (((word >> 4) & 0x1) == 0)
   8640                                             {
   8641                                               if (((word >> 11) & 0x1) == 0)
   8642                                                 {
   8643                                                   if (((word >> 12) & 0x1) == 0)
   8644                                                     {
   8645                                                       /* 33222222222211111111110000000000
   8646                                                          10987654321098765432109876543210
   8647                                                          xxxx0xxxxxx00000xxxxx1xx1x10010x
   8648                                                          whilelt.  */
   8649                                                       return 1966;
   8650                                                     }
   8651                                                   else
   8652                                                     {
   8653                                                       /* 33222222222211111111110000000000
   8654                                                          10987654321098765432109876543210
   8655                                                          xxxx0xxxxxx01000xxxxx1xx1x10010x
   8656                                                          whilelt.  */
   8657                                                       return 1967;
   8658                                                     }
   8659                                                 }
   8660                                               else
   8661                                                 {
   8662                                                   if (((word >> 12) & 0x1) == 0)
   8663                                                     {
   8664                                                       /* 33222222222211111111110000000000
   8665                                                          10987654321098765432109876543210
   8666                                                          xxxx0xxxxxx10000xxxxx1xx1x10010x
   8667                                                          whilelo.  */
   8668                                                       return 1962;
   8669                                                     }
   8670                                                   else
   8671                                                     {
   8672                                                       /* 33222222222211111111110000000000
   8673                                                          10987654321098765432109876543210
   8674                                                          xxxx0xxxxxx11000xxxxx1xx1x10010x
   8675                                                          whilelo.  */
   8676                                                       return 1963;
   8677                                                     }
   8678                                                 }
   8679                                             }
   8680                                           else
   8681                                             {
   8682                                               if (((word >> 11) & 0x1) == 0)
   8683                                                 {
   8684                                                   if (((word >> 12) & 0x1) == 0)
   8685                                                     {
   8686                                                       /* 33222222222211111111110000000000
   8687                                                          10987654321098765432109876543210
   8688                                                          xxxx1xxxxxx00000xxxxx1xx1x10010x
   8689                                                          whilele.  */
   8690                                                       return 1960;
   8691                                                     }
   8692                                                   else
   8693                                                     {
   8694                                                       /* 33222222222211111111110000000000
   8695                                                          10987654321098765432109876543210
   8696                                                          xxxx1xxxxxx01000xxxxx1xx1x10010x
   8697                                                          whilele.  */
   8698                                                       return 1961;
   8699                                                     }
   8700                                                 }
   8701                                               else
   8702                                                 {
   8703                                                   if (((word >> 12) & 0x1) == 0)
   8704                                                     {
   8705                                                       /* 33222222222211111111110000000000
   8706                                                          10987654321098765432109876543210
   8707                                                          xxxx1xxxxxx10000xxxxx1xx1x10010x
   8708                                                          whilels.  */
   8709                                                       return 1964;
   8710                                                     }
   8711                                                   else
   8712                                                     {
   8713                                                       /* 33222222222211111111110000000000
   8714                                                          10987654321098765432109876543210
   8715                                                          xxxx1xxxxxx11000xxxxx1xx1x10010x
   8716                                                          whilels.  */
   8717                                                       return 1965;
   8718                                                     }
   8719                                                 }
   8720                                             }
   8721                                         }
   8722                                     }
   8723                                   else
   8724                                     {
   8725                                       if (((word >> 31) & 0x1) == 0)
   8726                                         {
   8727                                           if (((word >> 21) & 0x1) == 0)
   8728                                             {
   8729                                               if (((word >> 10) & 0x1) == 0)
   8730                                                 {
   8731                                                   if (((word >> 11) & 0x1) == 0)
   8732                                                     {
   8733                                                       /* 33222222222211111111110000000000
   8734                                                          10987654321098765432109876543210
   8735                                                          xxxxxxxxxx00x000xxxxx0xx1x100110
   8736                                                          fadd.  */
   8737                                                       return 1336;
   8738                                                     }
   8739                                                   else
   8740                                                     {
   8741                                                       if (((word >> 12) & 0x1) == 0)
   8742                                                         {
   8743                                                           /* 33222222222211111111110000000000
   8744                                                              10987654321098765432109876543210
   8745                                                              xxxxxxxxxx010000xxxxx0xx1x100110
   8746                                                              fmul.  */
   8747                                                           return 1403;
   8748                                                         }
   8749                                                       else
   8750                                                         {
   8751                                                           /* 33222222222211111111110000000000
   8752                                                              10987654321098765432109876543210
   8753                                                              xxxxxxxxxx011000xxxxx0xx1x100110
   8754                                                              frecps.  */
   8755                                                           return 1416;
   8756                                                         }
   8757                                                     }
   8758                                                 }
   8759                                               else
   8760                                                 {
   8761                                                   if (((word >> 11) & 0x1) == 0)
   8762                                                     {
   8763                                                       /* 33222222222211111111110000000000
   8764                                                          10987654321098765432109876543210
   8765                                                          xxxxxxxxxx10x000xxxxx0xx1x100110
   8766                                                          fsub.  */
   8767                                                       return 1429;
   8768                                                     }
   8769                                                   else
   8770                                                     {
   8771                                                       if (((word >> 12) & 0x1) == 0)
   8772                                                         {
   8773                                                           /* 33222222222211111111110000000000
   8774                                                              10987654321098765432109876543210
   8775                                                              xxxxxxxxxx110000xxxxx0xx1x100110
   8776                                                              ftsmul.  */
   8777                                                           return 1435;
   8778                                                         }
   8779                                                       else
   8780                                                         {
   8781                                                           /* 33222222222211111111110000000000
   8782                                                              10987654321098765432109876543210
   8783                                                              xxxxxxxxxx111000xxxxx0xx1x100110
   8784                                                              frsqrts.  */
   8785                                                           return 1426;
   8786                                                         }
   8787                                                     }
   8788                                                 }
   8789                                             }
   8790                                           else
   8791                                             {
   8792                                               /* 33222222222211111111110000000000
   8793                                                  10987654321098765432109876543210
   8794                                                  xxxxxxxxxxxxx000xxxxx1xx1x100110
   8795                                                  fmla.  */
   8796                                               return 1394;
   8797                                             }
   8798                                         }
   8799                                       else
   8800                                         {
   8801                                           /* 33222222222211111111110000000000
   8802                                              10987654321098765432109876543210
   8803                                              xxxxxxxxxxxxx000xxxxxxxx1x100111
   8804                                              str.  */
   8805                                           return 1881;
   8806                                         }
   8807                                     }
   8808                                 }
   8809                               else
   8810                                 {
   8811                                   if (((word >> 21) & 0x1) == 0)
   8812                                     {
   8813                                       if (((word >> 30) & 0x1) == 0)
   8814                                         {
   8815                                           if (((word >> 31) & 0x1) == 0)
   8816                                             {
   8817                                               if (((word >> 4) & 0x1) == 0)
   8818                                                 {
   8819                                                   /* 33222222222211111111110000000000
   8820                                                      10987654321098765432109876543210
   8821                                                      xxxx0xxxxxxxx100xxxxx0xx1x100100
   8822                                                      cmplt.  */
   8823                                                   return 1295;
   8824                                                 }
   8825                                               else
   8826                                                 {
   8827                                                   /* 33222222222211111111110000000000
   8828                                                      10987654321098765432109876543210
   8829                                                      xxxx1xxxxxxxx100xxxxx0xx1x100100
   8830                                                      cmple.  */
   8831                                                   return 1289;
   8832                                                 }
   8833                                             }
   8834                                           else
   8835                                             {
   8836                                               if (((word >> 23) & 0x1) == 0)
   8837                                                 {
   8838                                                   /* 33222222222211111111110000000000
   8839                                                      10987654321098765432109876543210
   8840                                                      xxxxxxxxxxxxx100xxxxx0x01x100101
   8841                                                      ld1rqw.  */
   8842                                                   return 1504;
   8843                                                 }
   8844                                               else
   8845                                                 {
   8846                                                   /* 33222222222211111111110000000000
   8847                                                      10987654321098765432109876543210
   8848                                                      xxxxxxxxxxxxx100xxxxx0x11x100101
   8849                                                      ld1rqd.  */
   8850                                                   return 1500;
   8851                                                 }
   8852                                             }
   8853                                         }
   8854                                       else
   8855                                         {
   8856                                           if (((word >> 16) & 0x1) == 0)
   8857                                             {
   8858                                               if (((word >> 17) & 0x1) == 0)
   8859                                                 {
   8860                                                   if (((word >> 18) & 0x1) == 0)
   8861                                                     {
   8862                                                       if (((word >> 19) & 0x1) == 0)
   8863                                                         {
   8864                                                           if (((word >> 20) & 0x1) == 0)
   8865                                                             {
   8866                                                               /* 33222222222211111111110000000000
   8867                                                                  10987654321098765432109876543210
   8868                                                                  xxxxxxxxxxxxx100000000xx1x10011x
   8869                                                                  faddv.  */
   8870                                                               return 1340;
   8871                                                             }
   8872                                                           else
   8873                                                             {
   8874                                                               if (((word >> 4) & 0x1) == 0)
   8875                                                                 {
   8876                                                                   /* 33222222222211111111110000000000
   8877                                                                      10987654321098765432109876543210
   8878                                                                      xxxx0xxxxxxxx100000010xx1x10011x
   8879                                                                      fcmge.  */
   8880                                                                   return 1347;
   8881                                                                 }
   8882                                                               else
   8883                                                                 {
   8884                                                                   /* 33222222222211111111110000000000
   8885                                                                      10987654321098765432109876543210
   8886                                                                      xxxx1xxxxxxxx100000010xx1x10011x
   8887                                                                      fcmgt.  */
   8888                                                                   return 1349;
   8889                                                                 }
   8890                                                             }
   8891                                                         }
   8892                                                       else
   8893                                                         {
   8894                                                           /* 33222222222211111111110000000000
   8895                                                              10987654321098765432109876543210
   8896                                                              xxxxxxxxxxxxx1000001x0xx1x10011x
   8897                                                              fadda.  */
   8898                                                           return 1339;
   8899                                                         }
   8900                                                     }
   8901                                                   else
   8902                                                     {
   8903                                                       /* 33222222222211111111110000000000
   8904                                                          10987654321098765432109876543210
   8905                                                          xxxxxxxxxxxxx100001xx0xx1x10011x
   8906                                                          fmaxnmv.  */
   8907                                                       return 1386;
   8908                                                     }
   8909                                                 }
   8910                                               else
   8911                                                 {
   8912                                                   if (((word >> 18) & 0x1) == 0)
   8913                                                     {
   8914                                                       /* 33222222222211111111110000000000
   8915                                                          10987654321098765432109876543210
   8916                                                          xxxxxxxxxxxxx100010xx0xx1x10011x
   8917                                                          fcmeq.  */
   8918                                                       return 1345;
   8919                                                     }
   8920                                                   else
   8921                                                     {
   8922                                                       if (((word >> 19) & 0x1) == 0)
   8923                                                         {
   8924                                                           /* 33222222222211111111110000000000
   8925                                                              10987654321098765432109876543210
   8926                                                              xxxxxxxxxxxxx1000110x0xx1x10011x
   8927                                                              fmaxv.  */
   8928                                                           return 1387;
   8929                                                         }
   8930                                                       else
   8931                                                         {
   8932                                                           /* 33222222222211111111110000000000
   8933                                                              10987654321098765432109876543210
   8934                                                              xxxxxxxxxxxxx1000111x0xx1x10011x
   8935                                                              frecpe.  */
   8936                                                           return 1415;
   8937                                                         }
   8938                                                     }
   8939                                                 }
   8940                                             }
   8941                                           else
   8942                                             {
   8943                                               if (((word >> 17) & 0x1) == 0)
   8944                                                 {
   8945                                                   if (((word >> 18) & 0x1) == 0)
   8946                                                     {
   8947                                                       if (((word >> 4) & 0x1) == 0)
   8948                                                         {
   8949                                                           /* 33222222222211111111110000000000
   8950                                                              10987654321098765432109876543210
   8951                                                              xxxx0xxxxxxxx100100xx0xx1x10011x
   8952                                                              fcmlt.  */
   8953                                                           return 1352;
   8954                                                         }
   8955                                                       else
   8956                                                         {
   8957                                                           /* 33222222222211111111110000000000
   8958                                                              10987654321098765432109876543210
   8959                                                              xxxx1xxxxxxxx100100xx0xx1x10011x
   8960                                                              fcmle.  */
   8961                                                           return 1351;
   8962                                                         }
   8963                                                     }
   8964                                                   else
   8965                                                     {
   8966                                                       /* 33222222222211111111110000000000
   8967                                                          10987654321098765432109876543210
   8968                                                          xxxxxxxxxxxxx100101xx0xx1x10011x
   8969                                                          fminnmv.  */
   8970                                                       return 1392;
   8971                                                     }
   8972                                                 }
   8973                                               else
   8974                                                 {
   8975                                                   if (((word >> 18) & 0x1) == 0)
   8976                                                     {
   8977                                                       /* 33222222222211111111110000000000
   8978                                                          10987654321098765432109876543210
   8979                                                          xxxxxxxxxxxxx100110xx0xx1x10011x
   8980                                                          fcmne.  */
   8981                                                       return 1353;
   8982                                                     }
   8983                                                   else
   8984                                                     {
   8985                                                       if (((word >> 19) & 0x1) == 0)
   8986                                                         {
   8987                                                           /* 33222222222211111111110000000000
   8988                                                              10987654321098765432109876543210
   8989                                                              xxxxxxxxxxxxx1001110x0xx1x10011x
   8990                                                              fminv.  */
   8991                                                           return 1393;
   8992                                                         }
   8993                                                       else
   8994                                                         {
   8995                                                           /* 33222222222211111111110000000000
   8996                                                              10987654321098765432109876543210
   8997                                                              xxxxxxxxxxxxx1001111x0xx1x10011x
   8998                                                              frsqrte.  */
   8999                                                           return 1425;
   9000                                                         }
   9001                                                     }
   9002                                                 }
   9003                                             }
   9004                                         }
   9005                                     }
   9006                                   else
   9007                                     {
   9008                                       if (((word >> 30) & 0x1) == 0)
   9009                                         {
   9010                                           if (((word >> 4) & 0x1) == 0)
   9011                                             {
   9012                                               /* 33222222222211111111110000000000
   9013                                                  10987654321098765432109876543210
   9014                                                  xxxx0xxxxxxxx100xxxxx1xx1x10010x
   9015                                                  ctermeq.  */
   9016                                               return 1310;
   9017                                             }
   9018                                           else
   9019                                             {
   9020                                               /* 33222222222211111111110000000000
   9021                                                  10987654321098765432109876543210
   9022                                                  xxxx1xxxxxxxx100xxxxx1xx1x10010x
   9023                                                  ctermne.  */
   9024                                               return 1311;
   9025                                             }
   9026                                         }
   9027                                       else
   9028                                         {
   9029                                           /* 33222222222211111111110000000000
   9030                                              10987654321098765432109876543210
   9031                                              xxxxxxxxxxxxx100xxxxx1xx1x10011x
   9032                                              fmls.  */
   9033                                           return 1398;
   9034                                         }
   9035                                     }
   9036                                 }
   9037                             }
   9038                           else
   9039                             {
   9040                               if (((word >> 30) & 0x1) == 0)
   9041                                 {
   9042                                   if (((word >> 21) & 0x1) == 0)
   9043                                     {
   9044                                       if (((word >> 22) & 0x1) == 0)
   9045                                         {
   9046                                           if (((word >> 23) & 0x1) == 0)
   9047                                             {
   9048                                               if (((word >> 31) & 0x1) == 0)
   9049                                                 {
   9050                                                   if (((word >> 9) & 0x1) == 0)
   9051                                                     {
   9052                                                       if (((word >> 20) & 0x1) == 0)
   9053                                                         {
   9054                                                           if (((word >> 4) & 0x1) == 0)
   9055                                                             {
   9056                                                               /* 33222222222211111111110000000000
   9057                                                                  10987654321098765432109876543210
   9058                                                                  xxxx0xxxx0xxxx10xxxx00001x100100
   9059                                                                  and.  */
   9060                                                               return 1241;
   9061                                                             }
   9062                                                           else
   9063                                                             {
   9064                                                               /* 33222222222211111111110000000000
   9065                                                                  10987654321098765432109876543210
   9066                                                                  xxxx1xxxx0xxxx10xxxx00001x100100
   9067                                                                  bic.  */
   9068                                                               return 1253;
   9069                                                             }
   9070                                                         }
   9071                                                       else
   9072                                                         {
   9073                                                           if (((word >> 19) & 0x1) == 0)
   9074                                                             {
   9075                                                               /* 33222222222211111111110000000000
   9076                                                                  10987654321098765432109876543210
   9077                                                                  xxxxxxxxx0xxxx10xxx010001x100100
   9078                                                                  brka.  */
   9079                                                               return 1255;
   9080                                                             }
   9081                                                           else
   9082                                                             {
   9083                                                               /* 33222222222211111111110000000000
   9084                                                                  10987654321098765432109876543210
   9085                                                                  xxxxxxxxx0xxxx10xxx110001x100100
   9086                                                                  brkn.  */
   9087                                                               return 1259;
   9088                                                             }
   9089                                                         }
   9090                                                     }
   9091                                                   else
   9092                                                     {
   9093                                                       if (((word >> 4) & 0x1) == 0)
   9094                                                         {
   9095                                                           /* 33222222222211111111110000000000
   9096                                                              10987654321098765432109876543210
   9097                                                              xxxx0xxxx1xxxx10xxxxx0001x100100
   9098                                                              eor.  */
   9099                                                           return 1328;
   9100                                                         }
   9101                                                       else
   9102                                                         {
   9103                                                           /* 33222222222211111111110000000000
   9104                                                              10987654321098765432109876543210
   9105                                                              xxxx1xxxx1xxxx10xxxxx0001x100100
   9106                                                              sel.  */
   9107                                                           return 1761;
   9108                                                         }
   9109                                                     }
   9110                                                 }
   9111                                               else
   9112                                                 {
   9113                                                   if (((word >> 13) & 0x1) == 0)
   9114                                                     {
   9115                                                       /* 33222222222211111111110000000000
   9116                                                          10987654321098765432109876543210
   9117                                                          xxxxxxxxxxxxx010xxxxx0001x100101
   9118                                                          ld1sh.  */
   9119                                                       return 1527;
   9120                                                     }
   9121                                                   else
   9122                                                     {
   9123                                                       /* 33222222222211111111110000000000
   9124                                                          10987654321098765432109876543210
   9125                                                          xxxxxxxxxxxxx110xxxxx0001x100101
   9126                                                          ldff1sh.  */
   9127                                                       return 1616;
   9128                                                     }
   9129                                                 }
   9130                                             }
   9131                                           else
   9132                                             {
   9133                                               if (((word >> 31) & 0x1) == 0)
   9134                                                 {
   9135                                                   if (((word >> 9) & 0x1) == 0)
   9136                                                     {
   9137                                                       if (((word >> 20) & 0x1) == 0)
   9138                                                         {
   9139                                                           if (((word >> 4) & 0x1) == 0)
   9140                                                             {
   9141                                                               /* 33222222222211111111110000000000
   9142                                                                  10987654321098765432109876543210
   9143                                                                  xxxx0xxxx0xxxx10xxxx00011x100100
   9144                                                                  orr.  */
   9145                                                               return 1697;
   9146                                                             }
   9147                                                           else
   9148                                                             {
   9149                                                               /* 33222222222211111111110000000000
   9150                                                                  10987654321098765432109876543210
   9151                                                                  xxxx1xxxx0xxxx10xxxx00011x100100
   9152                                                                  orn.  */
   9153                                                               return 1692;
   9154                                                             }
   9155                                                         }
   9156                                                       else
   9157                                                         {
   9158                                                           /* 33222222222211111111110000000000
   9159                                                              10987654321098765432109876543210
   9160                                                              xxxxxxxxx0xxxx10xxxx10011x100100
   9161                                                              brkb.  */
   9162                                                           return 1257;
   9163                                                         }
   9164                                                     }
   9165                                                   else
   9166                                                     {
   9167                                                       if (((word >> 4) & 0x1) == 0)
   9168                                                         {
   9169                                                           /* 33222222222211111111110000000000
   9170                                                              10987654321098765432109876543210
   9171                                                              xxxx0xxxx1xxxx10xxxxx0011x100100
   9172                                                              nor.  */
   9173                                                           return 1689;
   9174                                                         }
   9175                                                       else
   9176                                                         {
   9177                                                           /* 33222222222211111111110000000000
   9178                                                              10987654321098765432109876543210
   9179                                                              xxxx1xxxx1xxxx10xxxxx0011x100100
   9180                                                              nand.  */
   9181                                                           return 1686;
   9182                                                         }
   9183                                                     }
   9184                                                 }
   9185                                               else
   9186                                                 {
   9187                                                   if (((word >> 13) & 0x1) == 0)
   9188                                                     {
   9189                                                       /* 33222222222211111111110000000000
   9190                                                          10987654321098765432109876543210
   9191                                                          xxxxxxxxxxxxx010xxxxx0011x100101
   9192                                                          ld1sb.  */
   9193                                                       return 1515;
   9194                                                     }
   9195                                                   else
   9196                                                     {
   9197                                                       /* 33222222222211111111110000000000
   9198                                                          10987654321098765432109876543210
   9199                                                          xxxxxxxxxxxxx110xxxxx0011x100101
   9200                                                          ldff1sb.  */
   9201                                                       return 1607;
   9202                                                     }
   9203                                                 }
   9204                                             }
   9205                                         }
   9206                                       else
   9207                                         {
   9208                                           if (((word >> 23) & 0x1) == 0)
   9209                                             {
   9210                                               if (((word >> 31) & 0x1) == 0)
   9211                                                 {
   9212                                                   if (((word >> 4) & 0x1) == 0)
   9213                                                     {
   9214                                                       if (((word >> 9) & 0x1) == 0)
   9215                                                         {
   9216                                                           if (((word >> 20) & 0x1) == 0)
   9217                                                             {
   9218                                                               /* 33222222222211111111110000000000
   9219                                                                  10987654321098765432109876543210
   9220                                                                  xxxx0xxxx0xxxx10xxxx00101x100100
   9221                                                                  ands.  */
   9222                                                               return 1242;
   9223                                                             }
   9224                                                           else
   9225                                                             {
   9226                                                               if (((word >> 19) & 0x1) == 0)
   9227                                                                 {
   9228                                                                   /* 33222222222211111111110000000000
   9229                                                                      10987654321098765432109876543210
   9230                                                                      xxxx0xxxx0xxxx10xxx010101x100100
   9231                                                                      brkas.  */
   9232                                                                   return 1256;
   9233                                                                 }
   9234                                                               else
   9235                                                                 {
   9236                                                                   /* 33222222222211111111110000000000
   9237                                                                      10987654321098765432109876543210
   9238                                                                      xxxx0xxxx0xxxx10xxx110101x100100
   9239                                                                      brkns.  */
   9240                                                                   return 1260;
   9241                                                                 }
   9242                                                             }
   9243                                                         }
   9244                                                       else
   9245                                                         {
   9246                                                           /* 33222222222211111111110000000000
   9247                                                              10987654321098765432109876543210
   9248                                                              xxxx0xxxx1xxxx10xxxxx0101x100100
   9249                                                              eors.  */
   9250                                                           return 1329;
   9251                                                         }
   9252                                                     }
   9253                                                   else
   9254                                                     {
   9255                                                       /* 33222222222211111111110000000000
   9256                                                          10987654321098765432109876543210
   9257                                                          xxxx1xxxxxxxxx10xxxxx0101x100100
   9258                                                          bics.  */
   9259                                                       return 1254;
   9260                                                     }
   9261                                                 }
   9262                                               else
   9263                                                 {
   9264                                                   if (((word >> 13) & 0x1) == 0)
   9265                                                     {
   9266                                                       /* 33222222222211111111110000000000
   9267                                                          10987654321098765432109876543210
   9268                                                          xxxxxxxxxxxxx010xxxxx0101x100101
   9269                                                          ld1w.  */
   9270                                                       return 1546;
   9271                                                     }
   9272                                                   else
   9273                                                     {
   9274                                                       /* 33222222222211111111110000000000
   9275                                                          10987654321098765432109876543210
   9276                                                          xxxxxxxxxxxxx110xxxxx0101x100101
   9277                                                          ldff1w.  */
   9278                                                       return 1632;
   9279                                                     }
   9280                                                 }
   9281                                             }
   9282                                           else
   9283                                             {
   9284                                               if (((word >> 31) & 0x1) == 0)
   9285                                                 {
   9286                                                   if (((word >> 4) & 0x1) == 0)
   9287                                                     {
   9288                                                       if (((word >> 9) & 0x1) == 0)
   9289                                                         {
   9290                                                           if (((word >> 20) & 0x1) == 0)
   9291                                                             {
   9292                                                               /* 33222222222211111111110000000000
   9293                                                                  10987654321098765432109876543210
   9294                                                                  xxxx0xxxx0xxxx10xxxx00111x100100
   9295                                                                  orrs.  */
   9296                                                               return 1698;
   9297                                                             }
   9298                                                           else
   9299                                                             {
   9300                                                               /* 33222222222211111111110000000000
   9301                                                                  10987654321098765432109876543210
   9302                                                                  xxxx0xxxx0xxxx10xxxx10111x100100
   9303                                                                  brkbs.  */
   9304                                                               return 1258;
   9305                                                             }
   9306                                                         }
   9307                                                       else
   9308                                                         {
   9309                                                           /* 33222222222211111111110000000000
   9310                                                              10987654321098765432109876543210
   9311                                                              xxxx0xxxx1xxxx10xxxxx0111x100100
   9312                                                              nors.  */
   9313                                                           return 1690;
   9314                                                         }
   9315                                                     }
   9316                                                   else
   9317                                                     {
   9318                                                       if (((word >> 9) & 0x1) == 0)
   9319                                                         {
   9320                                                           /* 33222222222211111111110000000000
   9321                                                              10987654321098765432109876543210
   9322                                                              xxxx1xxxx0xxxx10xxxxx0111x100100
   9323                                                              orns.  */
   9324                                                           return 1693;
   9325                                                         }
   9326                                                       else
   9327                                                         {
   9328                                                           /* 33222222222211111111110000000000
   9329                                                              10987654321098765432109876543210
   9330                                                              xxxx1xxxx1xxxx10xxxxx0111x100100
   9331                                                              nands.  */
   9332                                                           return 1687;
   9333                                                         }
   9334                                                     }
   9335                                                 }
   9336                                               else
   9337                                                 {
   9338                                                   if (((word >> 13) & 0x1) == 0)
   9339                                                     {
   9340                                                       /* 33222222222211111111110000000000
   9341                                                          10987654321098765432109876543210
   9342                                                          xxxxxxxxxxxxx010xxxxx0111x100101
   9343                                                          ld1sb.  */
   9344                                                       return 1517;
   9345                                                     }
   9346                                                   else
   9347                                                     {
   9348                                                       /* 33222222222211111111110000000000
   9349                                                          10987654321098765432109876543210
   9350                                                          xxxxxxxxxxxxx110xxxxx0111x100101
   9351                                                          ldff1sb.  */
   9352                                                       return 1609;
   9353                                                     }
   9354                                                 }
   9355                                             }
   9356                                         }
   9357                                     }
   9358                                   else
   9359                                     {
   9360                                       if (((word >> 13) & 0x1) == 0)
   9361                                         {
   9362                                           if (((word >> 22) & 0x1) == 0)
   9363                                             {
   9364                                               if (((word >> 23) & 0x1) == 0)
   9365                                                 {
   9366                                                   /* 33222222222211111111110000000000
   9367                                                      10987654321098765432109876543210
   9368                                                      xxxxxxxxxxxxx010xxxxx1001x10010x
   9369                                                      ld1sh.  */
   9370                                                   return 1528;
   9371                                                 }
   9372                                               else
   9373                                                 {
   9374                                                   /* 33222222222211111111110000000000
   9375                                                      10987654321098765432109876543210
   9376                                                      xxxxxxxxxxxxx010xxxxx1011x10010x
   9377                                                      ld1sb.  */
   9378                                                   return 1516;
   9379                                                 }
   9380                                             }
   9381                                           else
   9382                                             {
   9383                                               if (((word >> 23) & 0x1) == 0)
   9384                                                 {
   9385                                                   /* 33222222222211111111110000000000
   9386                                                      10987654321098765432109876543210
   9387                                                      xxxxxxxxxxxxx010xxxxx1101x10010x
   9388                                                      ld1w.  */
   9389                                                   return 1547;
   9390                                                 }
   9391                                               else
   9392                                                 {
   9393                                                   /* 33222222222211111111110000000000
   9394                                                      10987654321098765432109876543210
   9395                                                      xxxxxxxxxxxxx010xxxxx1111x10010x
   9396                                                      ld1d.  */
   9397                                                   return 1469;
   9398                                                 }
   9399                                             }
   9400                                         }
   9401                                       else
   9402                                         {
   9403                                           if (((word >> 22) & 0x1) == 0)
   9404                                             {
   9405                                               if (((word >> 23) & 0x1) == 0)
   9406                                                 {
   9407                                                   /* 33222222222211111111110000000000
   9408                                                      10987654321098765432109876543210
   9409                                                      xxxxxxxxxxxxx110xxxxx1001x10010x
   9410                                                      ldff1sh.  */
   9411                                                   return 1617;
   9412                                                 }
   9413                                               else
   9414                                                 {
   9415                                                   /* 33222222222211111111110000000000
   9416                                                      10987654321098765432109876543210
   9417                                                      xxxxxxxxxxxxx110xxxxx1011x10010x
   9418                                                      ldff1sb.  */
   9419                                                   return 1608;
   9420                                                 }
   9421                                             }
   9422                                           else
   9423                                             {
   9424                                               if (((word >> 23) & 0x1) == 0)
   9425                                                 {
   9426                                                   /* 33222222222211111111110000000000
   9427                                                      10987654321098765432109876543210
   9428                                                      xxxxxxxxxxxxx110xxxxx1101x10010x
   9429                                                      ldff1w.  */
   9430                                                   return 1633;
   9431                                                 }
   9432                                               else
   9433                                                 {
   9434                                                   /* 33222222222211111111110000000000
   9435                                                      10987654321098765432109876543210
   9436                                                      xxxxxxxxxxxxx110xxxxx1111x10010x
   9437                                                      ldff1d.  */
   9438                                                   return 1589;
   9439                                                 }
   9440                                             }
   9441                                         }
   9442                                     }
   9443                                 }
   9444                               else
   9445                                 {
   9446                                   if (((word >> 13) & 0x1) == 0)
   9447                                     {
   9448                                       if (((word >> 31) & 0x1) == 0)
   9449                                         {
   9450                                           if (((word >> 21) & 0x1) == 0)
   9451                                             {
   9452                                               if (((word >> 4) & 0x1) == 0)
   9453                                                 {
   9454                                                   /* 33222222222211111111110000000000
   9455                                                      10987654321098765432109876543210
   9456                                                      xxxx0xxxxxxxx010xxxxx0xx1x100110
   9457                                                      fcmge.  */
   9458                                                   return 1348;
   9459                                                 }
   9460                                               else
   9461                                                 {
   9462                                                   /* 33222222222211111111110000000000
   9463                                                      10987654321098765432109876543210
   9464                                                      xxxx1xxxxxxxx010xxxxx0xx1x100110
   9465                                                      fcmgt.  */
   9466                                                   return 1350;
   9467                                                 }
   9468                                             }
   9469                                           else
   9470                                             {
   9471                                               /* 33222222222211111111110000000000
   9472                                                  10987654321098765432109876543210
   9473                                                  xxxxxxxxxxxxx010xxxxx1xx1x100110
   9474                                                  fnmla.  */
   9475                                               return 1412;
   9476                                             }
   9477                                         }
   9478                                       else
   9479                                         {
   9480                                           if (((word >> 22) & 0x1) == 0)
   9481                                             {
   9482                                               /* 33222222222211111111110000000000
   9483                                                  10987654321098765432109876543210
   9484                                                  xxxxxxxxxxxxx010xxxxxx0x1x100111
   9485                                                  str.  */
   9486                                               return 1882;
   9487                                             }
   9488                                           else
   9489                                             {
   9490                                               if (((word >> 21) & 0x1) == 0)
   9491                                                 {
   9492                                                   /* 33222222222211111111110000000000
   9493                                                      10987654321098765432109876543210
   9494                                                      xxxxxxxxxxxxx010xxxxx01x1x100111
   9495                                                      st1w.  */
   9496                                                   return 1841;
   9497                                                 }
   9498                                               else
   9499                                                 {
   9500                                                   if (((word >> 23) & 0x1) == 0)
   9501                                                     {
   9502                                                       /* 33222222222211111111110000000000
   9503                                                          10987654321098765432109876543210
   9504                                                          xxxxxxxxxxxxx010xxxxx1101x100111
   9505                                                          st1w.  */
   9506                                                       return 1843;
   9507                                                     }
   9508                                                   else
   9509                                                     {
   9510                                                       /* 33222222222211111111110000000000
   9511                                                          10987654321098765432109876543210
   9512                                                          xxxxxxxxxxxxx010xxxxx1111x100111
   9513                                                          st1d.  */
   9514                                                       return 1820;
   9515                                                     }
   9516                                                 }
   9517                                             }
   9518                                         }
   9519                                     }
   9520                                   else
   9521                                     {
   9522                                       if (((word >> 21) & 0x1) == 0)
   9523                                         {
   9524                                           if (((word >> 31) & 0x1) == 0)
   9525                                             {
   9526                                               if (((word >> 4) & 0x1) == 0)
   9527                                                 {
   9528                                                   /* 33222222222211111111110000000000
   9529                                                      10987654321098765432109876543210
   9530                                                      xxxx0xxxxxxxx110xxxxx0xx1x100110
   9531                                                      fcmeq.  */
   9532                                                   return 1346;
   9533                                                 }
   9534                                               else
   9535                                                 {
   9536                                                   /* 33222222222211111111110000000000
   9537                                                      10987654321098765432109876543210
   9538                                                      xxxx1xxxxxxxx110xxxxx0xx1x100110
   9539                                                      fcmne.  */
   9540                                                   return 1354;
   9541                                                 }
   9542                                             }
   9543                                           else
   9544                                             {
   9545                                               if (((word >> 22) & 0x1) == 0)
   9546                                                 {
   9547                                                   if (((word >> 23) & 0x1) == 0)
   9548                                                     {
   9549                                                       /* 33222222222211111111110000000000
   9550                                                          10987654321098765432109876543210
   9551                                                          xxxxxxxxxxxxx110xxxxx0001x100111
   9552                                                          stnt1w.  */
   9553                                                       return 1879;
   9554                                                     }
   9555                                                   else
   9556                                                     {
   9557                                                       /* 33222222222211111111110000000000
   9558                                                          10987654321098765432109876543210
   9559                                                          xxxxxxxxxxxxx110xxxxx0011x100111
   9560                                                          stnt1d.  */
   9561                                                       return 1875;
   9562                                                     }
   9563                                                 }
   9564                                               else
   9565                                                 {
   9566                                                   if (((word >> 23) & 0x1) == 0)
   9567                                                     {
   9568                                                       /* 33222222222211111111110000000000
   9569                                                          10987654321098765432109876543210
   9570                                                          xxxxxxxxxxxxx110xxxxx0101x100111
   9571                                                          st3w.  */
   9572                                                       return 1863;
   9573                                                     }
   9574                                                   else
   9575                                                     {
   9576                                                       /* 33222222222211111111110000000000
   9577                                                          10987654321098765432109876543210
   9578                                                          xxxxxxxxxxxxx110xxxxx0111x100111
   9579                                                          st3d.  */
   9580                                                       return 1859;
   9581                                                     }
   9582                                                 }
   9583                                             }
   9584                                         }
   9585                                       else
   9586                                         {
   9587                                           if (((word >> 31) & 0x1) == 0)
   9588                                             {
   9589                                               /* 33222222222211111111110000000000
   9590                                                  10987654321098765432109876543210
   9591                                                  xxxxxxxxxxxxx110xxxxx1xx1x100110
   9592                                                  fnmls.  */
   9593                                               return 1413;
   9594                                             }
   9595                                           else
   9596                                             {
   9597                                               if (((word >> 22) & 0x1) == 0)
   9598                                                 {
   9599                                                   if (((word >> 23) & 0x1) == 0)
   9600                                                     {
   9601                                                       /* 33222222222211111111110000000000
   9602                                                          10987654321098765432109876543210
   9603                                                          xxxxxxxxxxxxx110xxxxx1001x100111
   9604                                                          st2w.  */
   9605                                                       return 1855;
   9606                                                     }
   9607                                                   else
   9608                                                     {
   9609                                                       /* 33222222222211111111110000000000
   9610                                                          10987654321098765432109876543210
   9611                                                          xxxxxxxxxxxxx110xxxxx1011x100111
   9612                                                          st2d.  */
   9613                                                       return 1851;
   9614                                                     }
   9615                                                 }
   9616                                               else
   9617                                                 {
   9618                                                   if (((word >> 23) & 0x1) == 0)
   9619                                                     {
   9620                                                       /* 33222222222211111111110000000000
   9621                                                          10987654321098765432109876543210
   9622                                                          xxxxxxxxxxxxx110xxxxx1101x100111
   9623                                                          st4w.  */
   9624                                                       return 1871;
   9625                                                     }
   9626                                                   else
   9627                                                     {
   9628                                                       /* 33222222222211111111110000000000
   9629                                                          10987654321098765432109876543210
   9630                                                          xxxxxxxxxxxxx110xxxxx1111x100111
   9631                                                          st4d.  */
   9632                                                       return 1867;
   9633                                                     }
   9634                                                 }
   9635                                             }
   9636                                         }
   9637                                     }
   9638                                 }
   9639                             }
   9640                         }
   9641                       else
   9642                         {
   9643                           if (((word >> 21) & 0x1) == 0)
   9644                             {
   9645                               if (((word >> 30) & 0x1) == 0)
   9646                                 {
   9647                                   if (((word >> 14) & 0x1) == 0)
   9648                                     {
   9649                                       if (((word >> 13) & 0x1) == 0)
   9650                                         {
   9651                                           if (((word >> 4) & 0x1) == 0)
   9652                                             {
   9653                                               /* 33222222222211111111110000000000
   9654                                                  10987654321098765432109876543210
   9655                                                  xxxx0xxxxxxxx001xxxxx0xx1x10010x
   9656                                                  cmpeq.  */
   9657                                               return 1275;
   9658                                             }
   9659                                           else
   9660                                             {
   9661                                               /* 33222222222211111111110000000000
   9662                                                  10987654321098765432109876543210
   9663                                                  xxxx1xxxxxxxx001xxxxx0xx1x10010x
   9664                                                  cmpne.  */
   9665                                               return 1298;
   9666                                             }
   9667                                         }
   9668                                       else
   9669                                         {
   9670                                           if (((word >> 20) & 0x1) == 0)
   9671                                             {
   9672                                               if (((word >> 22) & 0x1) == 0)
   9673                                                 {
   9674                                                   if (((word >> 23) & 0x1) == 0)
   9675                                                     {
   9676                                                       /* 33222222222211111111110000000000
   9677                                                          10987654321098765432109876543210
   9678                                                          xxxxxxxxxxxxx101xxxx00001x10010x
   9679                                                          ld1sh.  */
   9680                                                       return 1534;
   9681                                                     }
   9682                                                   else
   9683                                                     {
   9684                                                       /* 33222222222211111111110000000000
   9685                                                          10987654321098765432109876543210
   9686                                                          xxxxxxxxxxxxx101xxxx00011x10010x
   9687                                                          ld1sb.  */
   9688                                                       return 1521;
   9689                                                     }
   9690                                                 }
   9691                                               else
   9692                                                 {
   9693                                                   if (((word >> 23) & 0x1) == 0)
   9694                                                     {
   9695                                                       /* 33222222222211111111110000000000
   9696                                                          10987654321098765432109876543210
   9697                                                          xxxxxxxxxxxxx101xxxx00101x10010x
   9698                                                          ld1w.  */
   9699                                                       return 1553;
   9700                                                     }
   9701                                                   else
   9702                                                     {
   9703                                                       /* 33222222222211111111110000000000
   9704                                                          10987654321098765432109876543210
   9705                                                          xxxxxxxxxxxxx101xxxx00111x10010x
   9706                                                          ld1sb.  */
   9707                                                       return 1523;
   9708                                                     }
   9709                                                 }
   9710                                             }
   9711                                           else
   9712                                             {
   9713                                               if (((word >> 22) & 0x1) == 0)
   9714                                                 {
   9715                                                   if (((word >> 23) & 0x1) == 0)
   9716                                                     {
   9717                                                       /* 33222222222211111111110000000000
   9718                                                          10987654321098765432109876543210
   9719                                                          xxxxxxxxxxxxx101xxxx10001x10010x
   9720                                                          ldnf1sh.  */
   9721                                                       return 1651;
   9722                                                     }
   9723                                                   else
   9724                                                     {
   9725                                                       /* 33222222222211111111110000000000
   9726                                                          10987654321098765432109876543210
   9727                                                          xxxxxxxxxxxxx101xxxx10011x10010x
   9728                                                          ldnf1sb.  */
   9729                                                       return 1648;
   9730                                                     }
   9731                                                 }
   9732                                               else
   9733                                                 {
   9734                                                   if (((word >> 23) & 0x1) == 0)
   9735                                                     {
   9736                                                       /* 33222222222211111111110000000000
   9737                                                          10987654321098765432109876543210
   9738                                                          xxxxxxxxxxxxx101xxxx10101x10010x
   9739                                                          ldnf1w.  */
   9740                                                       return 1654;
   9741                                                     }
   9742                                                   else
   9743                                                     {
   9744                                                       /* 33222222222211111111110000000000
   9745                                                          10987654321098765432109876543210
   9746                                                          xxxxxxxxxxxxx101xxxx10111x10010x
   9747                                                          ldnf1sb.  */
   9748                                                       return 1650;
   9749                                                     }
   9750                                                 }
   9751                                             }
   9752                                         }
   9753                                     }
   9754                                   else
   9755                                     {
   9756                                       if (((word >> 31) & 0x1) == 0)
   9757                                         {
   9758                                           if (((word >> 4) & 0x1) == 0)
   9759                                             {
   9760                                               if (((word >> 20) & 0x1) == 0)
   9761                                                 {
   9762                                                   if (((word >> 22) & 0x1) == 0)
   9763                                                     {
   9764                                                       /* 33222222222211111111110000000000
   9765                                                          10987654321098765432109876543210
   9766                                                          xxxx0xxxxxxxxx11xxxx000x1x100100
   9767                                                          brkpa.  */
   9768                                                       return 1261;
   9769                                                     }
   9770                                                   else
   9771                                                     {
   9772                                                       /* 33222222222211111111110000000000
   9773                                                          10987654321098765432109876543210
   9774                                                          xxxx0xxxxxxxxx11xxxx001x1x100100
   9775                                                          brkpas.  */
   9776                                                       return 1262;
   9777                                                     }
   9778                                                 }
   9779                                               else
   9780                                                 {
   9781                                                   if (((word >> 16) & 0x1) == 0)
   9782                                                     {
   9783                                                       if (((word >> 19) & 0x1) == 0)
   9784                                                         {
   9785                                                           /* 33222222222211111111110000000000
   9786                                                              10987654321098765432109876543210
   9787                                                              xxxx0xxxxxxxxx110xx010xx1x100100
   9788                                                              ptest.  */
   9789                                                           return 1731;
   9790                                                         }
   9791                                                       else
   9792                                                         {
   9793                                                           if (((word >> 10) & 0x1) == 0)
   9794                                                             {
   9795                                                               if (((word >> 12) & 0x1) == 0)
   9796                                                                 {
   9797                                                                   if (((word >> 13) & 0x1) == 0)
   9798                                                                     {
   9799                                                                       /* 33222222222211111111110000000000
   9800                                                                          10987654321098765432109876543210
   9801                                                                          xxxx0xxxxx0x00110xx110xx1x100100
   9802                                                                          pfirst.  */
   9803                                                                       return 1701;
   9804                                                                     }
   9805                                                                   else
   9806                                                                     {
   9807                                                                       /* 33222222222211111111110000000000
   9808                                                                          10987654321098765432109876543210
   9809                                                                          xxxx0xxxxx0x01110xx110xx1x100100
   9810                                                                          ptrue.  */
   9811                                                                       return 1732;
   9812                                                                     }
   9813                                                                 }
   9814                                                               else
   9815                                                                 {
   9816                                                                   if (((word >> 22) & 0x1) == 0)
   9817                                                                     {
   9818                                                                       /* 33222222222211111111110000000000
   9819                                                                          10987654321098765432109876543210
   9820                                                                          xxxx0xxxxx0x1x110xx1100x1x100100
   9821                                                                          rdffr.  */
   9822                                                                       return 1738;
   9823                                                                     }
   9824                                                                   else
   9825                                                                     {
   9826                                                                       /* 33222222222211111111110000000000
   9827                                                                          10987654321098765432109876543210
   9828                                                                          xxxx0xxxxx0x1x110xx1101x1x100100
   9829                                                                          rdffrs.  */
   9830                                                                       return 1739;
   9831                                                                     }
   9832                                                                 }
   9833                                                             }
   9834                                                           else
   9835                                                             {
   9836                                                               /* 33222222222211111111110000000000
   9837                                                                  10987654321098765432109876543210
   9838                                                                  xxxx0xxxxx1xxx110xx110xx1x100100
   9839                                                                  pfalse.  */
   9840                                                               return 1700;
   9841                                                             }
   9842                                                         }
   9843                                                     }
   9844                                                   else
   9845                                                     {
   9846                                                       if (((word >> 10) & 0x1) == 0)
   9847                                                         {
   9848                                                           if (((word >> 12) & 0x1) == 0)
   9849                                                             {
   9850                                                               /* 33222222222211111111110000000000
   9851                                                                  10987654321098765432109876543210
   9852                                                                  xxxx0xxxxx0x0x111xxx10xx1x100100
   9853                                                                  ptrues.  */
   9854                                                               return 1733;
   9855                                                             }
   9856                                                           else
   9857                                                             {
   9858                                                               /* 33222222222211111111110000000000
   9859                                                                  10987654321098765432109876543210
   9860                                                                  xxxx0xxxxx0x1x111xxx10xx1x100100
   9861                                                                  rdffr.  */
   9862                                                               return 1737;
   9863                                                             }
   9864                                                         }
   9865                                                       else
   9866                                                         {
   9867                                                           /* 33222222222211111111110000000000
   9868                                                              10987654321098765432109876543210
   9869                                                              xxxx0xxxxx1xxx111xxx10xx1x100100
   9870                                                              pnext.  */
   9871                                                           return 1702;
   9872                                                         }
   9873                                                     }
   9874                                                 }
   9875                                             }
   9876                                           else
   9877                                             {
   9878                                               if (((word >> 22) & 0x1) == 0)
   9879                                                 {
   9880                                                   /* 33222222222211111111110000000000
   9881                                                      10987654321098765432109876543210
   9882                                                      xxxx1xxxxxxxxx11xxxxx00x1x100100
   9883                                                      brkpb.  */
   9884                                                   return 1263;
   9885                                                 }
   9886                                               else
   9887                                                 {
   9888                                                   /* 33222222222211111111110000000000
   9889                                                      10987654321098765432109876543210
   9890                                                      xxxx1xxxxxxxxx11xxxxx01x1x100100
   9891                                                      brkpbs.  */
   9892                                                   return 1264;
   9893                                                 }
   9894                                             }
   9895                                         }
   9896                                       else
   9897                                         {
   9898                                           if (((word >> 13) & 0x1) == 0)
   9899                                             {
   9900                                               if (((word >> 22) & 0x1) == 0)
   9901                                                 {
   9902                                                   if (((word >> 23) & 0x1) == 0)
   9903                                                     {
   9904                                                       /* 33222222222211111111110000000000
   9905                                                          10987654321098765432109876543210
   9906                                                          xxxxxxxxxxxxx011xxxxx0001x100101
   9907                                                          ldnt1w.  */
   9908                                                       return 1662;
   9909                                                     }
   9910                                                   else
   9911                                                     {
   9912                                                       /* 33222222222211111111110000000000
   9913                                                          10987654321098765432109876543210
   9914                                                          xxxxxxxxxxxxx011xxxxx0011x100101
   9915                                                          ldnt1d.  */
   9916                                                       return 1658;
   9917                                                     }
   9918                                                 }
   9919                                               else
   9920                                                 {
   9921                                                   if (((word >> 23) & 0x1) == 0)
   9922                                                     {
   9923                                                       /* 33222222222211111111110000000000
   9924                                                          10987654321098765432109876543210
   9925                                                          xxxxxxxxxxxxx011xxxxx0101x100101
   9926                                                          ld3w.  */
   9927                                                       return 1570;
   9928                                                     }
   9929                                                   else
   9930                                                     {
   9931                                                       /* 33222222222211111111110000000000
   9932                                                          10987654321098765432109876543210
   9933                                                          xxxxxxxxxxxxx011xxxxx0111x100101
   9934                                                          ld3d.  */
   9935                                                       return 1566;
   9936                                                     }
   9937                                                 }
   9938                                             }
   9939                                           else
   9940                                             {
   9941                                               if (((word >> 22) & 0x1) == 0)
   9942                                                 {
   9943                                                   if (((word >> 23) & 0x1) == 0)
   9944                                                     {
   9945                                                       /* 33222222222211111111110000000000
   9946                                                          10987654321098765432109876543210
   9947                                                          xxxxxxxxxxxxx111xxxxx0001x100101
   9948                                                          ldnt1w.  */
   9949                                                       return 1663;
   9950                                                     }
   9951                                                   else
   9952                                                     {
   9953                                                       /* 33222222222211111111110000000000
   9954                                                          10987654321098765432109876543210
   9955                                                          xxxxxxxxxxxxx111xxxxx0011x100101
   9956                                                          ldnt1d.  */
   9957                                                       return 1659;
   9958                                                     }
   9959                                                 }
   9960                                               else
   9961                                                 {
   9962                                                   if (((word >> 23) & 0x1) == 0)
   9963                                                     {
   9964                                                       /* 33222222222211111111110000000000
   9965                                                          10987654321098765432109876543210
   9966                                                          xxxxxxxxxxxxx111xxxxx0101x100101
   9967                                                          ld3w.  */
   9968                                                       return 1571;
   9969                                                     }
   9970                                                   else
   9971                                                     {
   9972                                                       /* 33222222222211111111110000000000
   9973                                                          10987654321098765432109876543210
   9974                                                          xxxxxxxxxxxxx111xxxxx0111x100101
   9975                                                          ld3d.  */
   9976                                                       return 1567;
   9977                                                     }
   9978                                                 }
   9979                                             }
   9980                                         }
   9981                                     }
   9982                                 }
   9983                               else
   9984                                 {
   9985                                   if (((word >> 13) & 0x1) == 0)
   9986                                     {
   9987                                       if (((word >> 31) & 0x1) == 0)
   9988                                         {
   9989                                           if (((word >> 14) & 0x1) == 0)
   9990                                             {
   9991                                               if (((word >> 19) & 0x1) == 0)
   9992                                                 {
   9993                                                   if (((word >> 20) & 0x1) == 0)
   9994                                                     {
   9995                                                       if (((word >> 16) & 0x1) == 0)
   9996                                                         {
   9997                                                           if (((word >> 17) & 0x1) == 0)
   9998                                                             {
   9999                                                               if (((word >> 18) & 0x1) == 0)
   10000                                                                 {
   10001                                                                   /* 33222222222211111111110000000000
   10002                                                                      10987654321098765432109876543210
   10003                                                                      xxxxxxxxxxxxx001000000xx1x100110
   10004                                                                      fadd.  */
   10005                                                                   return 1337;
   10006                                                                 }
   10007                                                               else
   10008                                                                 {
   10009                                                                   /* 33222222222211111111110000000000
   10010                                                                      10987654321098765432109876543210
   10011                                                                      xxxxxxxxxxxxx001001000xx1x100110
   10012                                                                      fmaxnm.  */
   10013                                                                   return 1384;
   10014                                                                 }
   10015                                                             }
   10016                                                           else
   10017                                                             {
   10018                                                               if (((word >> 18) & 0x1) == 0)
   10019                                                                 {
   10020                                                                   /* 33222222222211111111110000000000
   10021                                                                      10987654321098765432109876543210
   10022                                                                      xxxxxxxxxxxxx001010000xx1x100110
   10023                                                                      fmul.  */
   10024                                                                   return 1404;
   10025                                                                 }
   10026                                                               else
   10027                                                                 {
   10028                                                                   /* 33222222222211111111110000000000
   10029                                                                      10987654321098765432109876543210
   10030                                                                      xxxxxxxxxxxxx001011000xx1x100110
   10031                                                                      fmax.  */
   10032                                                                   return 1382;
   10033                                                                 }
   10034                                                             }
   10035                                                         }
   10036                                                       else
   10037                                                         {
   10038                                                           if (((word >> 17) & 0x1) == 0)
   10039                                                             {
   10040                                                               if (((word >> 18) & 0x1) == 0)
   10041                                                                 {
   10042                                                                   /* 33222222222211111111110000000000
   10043                                                                      10987654321098765432109876543210
   10044                                                                      xxxxxxxxxxxxx001100000xx1x100110
   10045                                                                      fsub.  */
   10046                                                                   return 1430;
   10047                                                                 }
   10048                                                               else
   10049                                                                 {
   10050                                                                   /* 33222222222211111111110000000000
   10051                                                                      10987654321098765432109876543210
   10052                                                                      xxxxxxxxxxxxx001101000xx1x100110
   10053                                                                      fminnm.  */
   10054                                                                   return 1390;
   10055                                                                 }
   10056                                                             }
   10057                                                           else
   10058                                                             {
   10059                                                               if (((word >> 18) & 0x1) == 0)
   10060                                                                 {
   10061                                                                   /* 33222222222211111111110000000000
   10062                                                                      10987654321098765432109876543210
   10063                                                                      xxxxxxxxxxxxx001110000xx1x100110
   10064                                                                      fsubr.  */
   10065                                                                   return 1432;
   10066                                                                 }
   10067                                                               else
   10068                                                                 {
   10069                                                                   /* 33222222222211111111110000000000
   10070                                                                      10987654321098765432109876543210
   10071                                                                      xxxxxxxxxxxxx001111000xx1x100110
   10072                                                                      fmin.  */
   10073                                                                   return 1388;
   10074                                                                 }
   10075                                                             }
   10076                                                         }
   10077                                                     }
   10078                                                   else
   10079                                                     {
   10080                                                       /* 33222222222211111111110000000000
   10081                                                          10987654321098765432109876543210
   10082                                                          xxxxxxxxxxxxx001xxx010xx1x100110
   10083                                                          ftmad.  */
   10084                                                       return 1434;
   10085                                                     }
   10086                                                 }
   10087                                               else
   10088                                                 {
   10089                                                   if (((word >> 16) & 0x1) == 0)
   10090                                                     {
   10091                                                       if (((word >> 17) & 0x1) == 0)
   10092                                                         {
   10093                                                           if (((word >> 18) & 0x1) == 0)
   10094                                                             {
   10095                                                               if (((word >> 20) & 0x1) == 0)
   10096                                                                 {
   10097                                                                   /* 33222222222211111111110000000000
   10098                                                                      10987654321098765432109876543210
   10099                                                                      xxxxxxxxxxxxx001000100xx1x100110
   10100                                                                      fabd.  */
   10101                                                                   return 1332;
   10102                                                                 }
   10103                                                               else
   10104                                                                 {
   10105                                                                   /* 33222222222211111111110000000000
   10106                                                                      10987654321098765432109876543210
   10107                                                                      xxxxxxxxxxxxx001000110xx1x100110
   10108                                                                      fadd.  */
   10109                                                                   return 1338;
   10110                                                                 }
   10111                                                             }
   10112                                                           else
   10113                                                             {
   10114                                                               if (((word >> 20) & 0x1) == 0)
   10115                                                                 {
   10116                                                                   /* 33222222222211111111110000000000
   10117                                                                      10987654321098765432109876543210
   10118                                                                      xxxxxxxxxxxxx001001100xx1x100110
   10119                                                                      fdivr.  */
   10120                                                                   return 1378;
   10121                                                                 }
   10122                                                               else
   10123                                                                 {
   10124                                                                   /* 33222222222211111111110000000000
   10125                                                                      10987654321098765432109876543210
   10126                                                                      xxxxxxxxxxxxx001001110xx1x100110
   10127                                                                      fmaxnm.  */
   10128                                                                   return 1385;
   10129                                                                 }
   10130                                                             }
   10131                                                         }
   10132                                                       else
   10133                                                         {
   10134                                                           if (((word >> 18) & 0x1) == 0)
   10135                                                             {
   10136                                                               if (((word >> 20) & 0x1) == 0)
   10137                                                                 {
   10138                                                                   /* 33222222222211111111110000000000
   10139                                                                      10987654321098765432109876543210
   10140                                                                      xxxxxxxxxxxxx001010100xx1x100110
   10141                                                                      fmulx.  */
   10142                                                                   return 1409;
   10143                                                                 }
   10144                                                               else
   10145                                                                 {
   10146                                                                   /* 33222222222211111111110000000000
   10147                                                                      10987654321098765432109876543210
   10148                                                                      xxxxxxxxxxxxx001010110xx1x100110
   10149                                                                      fmul.  */
   10150                                                                   return 1405;
   10151                                                                 }
   10152                                                             }
   10153                                                           else
   10154                                                             {
   10155                                                               /* 33222222222211111111110000000000
   10156                                                                  10987654321098765432109876543210
   10157                                                                  xxxxxxxxxxxxx0010111x0xx1x100110
   10158                                                                  fmax.  */
   10159                                                               return 1383;
   10160                                                             }
   10161                                                         }
   10162                                                     }
   10163                                                   else
   10164                                                     {
   10165                                                       if (((word >> 17) & 0x1) == 0)
   10166                                                         {
   10167                                                           if (((word >> 18) & 0x1) == 0)
   10168                                                             {
   10169                                                               if (((word >> 20) & 0x1) == 0)
   10170                                                                 {
   10171                                                                   /* 33222222222211111111110000000000
   10172                                                                      10987654321098765432109876543210
   10173                                                                      xxxxxxxxxxxxx001100100xx1x100110
   10174                                                                      fscale.  */
   10175                                                                   return 1427;
   10176                                                                 }
   10177                                                               else
   10178                                                                 {
   10179                                                                   /* 33222222222211111111110000000000
   10180                                                                      10987654321098765432109876543210
   10181                                                                      xxxxxxxxxxxxx001100110xx1x100110
   10182                                                                      fsub.  */
   10183                                                                   return 1431;
   10184                                                                 }
   10185                                                             }
   10186                                                           else
   10187                                                             {
   10188                                                               if (((word >> 20) & 0x1) == 0)
   10189                                                                 {
   10190                                                                   /* 33222222222211111111110000000000
   10191                                                                      10987654321098765432109876543210
   10192                                                                      xxxxxxxxxxxxx001101100xx1x100110
   10193                                                                      fdiv.  */
   10194                                                                   return 1377;
   10195                                                                 }
   10196                                                               else
   10197                                                                 {
   10198                                                                   /* 33222222222211111111110000000000
   10199                                                                      10987654321098765432109876543210
   10200                                                                      xxxxxxxxxxxxx001101110xx1x100110
   10201                                                                      fminnm.  */
   10202                                                                   return 1391;
   10203                                                                 }
   10204                                                             }
   10205                                                         }
   10206                                                       else
   10207                                                         {
   10208                                                           if (((word >> 18) & 0x1) == 0)
   10209                                                             {
   10210                                                               /* 33222222222211111111110000000000
   10211                                                                  10987654321098765432109876543210
   10212                                                                  xxxxxxxxxxxxx0011101x0xx1x100110
   10213                                                                  fsubr.  */
   10214                                                               return 1433;
   10215                                                             }
   10216                                                           else
   10217                                                             {
   10218                                                               /* 33222222222211111111110000000000
   10219                                                                  10987654321098765432109876543210
   10220                                                                  xxxxxxxxxxxxx0011111x0xx1x100110
   10221                                                                  fmin.  */
   10222                                                               return 1389;
   10223                                                             }
   10224                                                         }
   10225                                                     }
   10226                                                 }
   10227                                             }
   10228                                           else
   10229                                             {
   10230                                               if (((word >> 4) & 0x1) == 0)
   10231                                                 {
   10232                                                   /* 33222222222211111111110000000000
   10233                                                      10987654321098765432109876543210
   10234                                                      xxxx0xxxxxxxx011xxxxx0xx1x100110
   10235                                                      fcmuo.  */
   10236                                                   return 1355;
   10237                                                 }
   10238                                               else
   10239                                                 {
   10240                                                   /* 33222222222211111111110000000000
   10241                                                      10987654321098765432109876543210
   10242                                                      xxxx1xxxxxxxx011xxxxx0xx1x100110
   10243                                                      facge.  */
   10244                                                   return 1334;
   10245                                                 }
   10246                                             }
   10247                                         }
   10248                                       else
   10249                                         {
   10250                                           if (((word >> 22) & 0x1) == 0)
   10251                                             {
   10252                                               if (((word >> 23) & 0x1) == 0)
   10253                                                 {
   10254                                                   /* 33222222222211111111110000000000
   10255                                                      10987654321098765432109876543210
   10256                                                      xxxxxxxxxxxxx0x1xxxxx0001x100111
   10257                                                      st1w.  */
   10258                                                   return 1837;
   10259                                                 }
   10260                                               else
   10261                                                 {
   10262                                                   /* 33222222222211111111110000000000
   10263                                                      10987654321098765432109876543210
   10264                                                      xxxxxxxxxxxxx0x1xxxxx0011x100111
   10265                                                      st1d.  */
   10266                                                   return 1816;
   10267                                                 }
   10268                                             }
   10269                                           else
   10270                                             {
   10271                                               /* 33222222222211111111110000000000
   10272                                                  10987654321098765432109876543210
   10273                                                  xxxxxxxxxxxxx0x1xxxxx01x1x100111
   10274                                                  st1w.  */
   10275                                               return 1842;
   10276                                             }
   10277                                         }
   10278                                     }
   10279                                   else
   10280                                     {
   10281                                       if (((word >> 14) & 0x1) == 0)
   10282                                         {
   10283                                           if (((word >> 31) & 0x1) == 0)
   10284                                             {
   10285                                               if (((word >> 16) & 0x1) == 0)
   10286                                                 {
   10287                                                   if (((word >> 17) & 0x1) == 0)
   10288                                                     {
   10289                                                       if (((word >> 18) & 0x1) == 0)
   10290                                                         {
   10291                                                           if (((word >> 19) & 0x1) == 0)
   10292                                                             {
   10293                                                               if (((word >> 20) & 0x1) == 0)
   10294                                                                 {
   10295                                                                   /* 33222222222211111111110000000000
   10296                                                                      10987654321098765432109876543210
   10297                                                                      xxxxxxxxxxxxx101000000xx1x100110
   10298                                                                      frintn.  */
   10299                                                                   return 1421;
   10300                                                                 }
   10301                                                               else
   10302                                                                 {
   10303                                                                   /* 33222222222211111111110000000000
   10304                                                                      10987654321098765432109876543210
   10305                                                                      xxxxxxxxxxxxx101000010xx1x100110
   10306                                                                      scvtf.  */
   10307                                                                   return 1751;
   10308                                                                 }
   10309                                                             }
   10310                                                           else
   10311                                                             {
   10312                                                               if (((word >> 20) & 0x1) == 0)
   10313                                                                 {
   10314                                                                   if (((word >> 22) & 0x1) == 0)
   10315                                                                     {
   10316                                                                       /* 33222222222211111111110000000000
   10317                                                                          10987654321098765432109876543210
   10318                                                                          xxxxxxxxxxxxx1010001000x1x100110
   10319                                                                          fcvt.  */
   10320                                                                       return 1357;
   10321                                                                     }
   10322                                                                   else
   10323                                                                     {
   10324                                                                       /* 33222222222211111111110000000000
   10325                                                                          10987654321098765432109876543210
   10326                                                                          xxxxxxxxxxxxx1010001001x1x100110
   10327                                                                          fcvt.  */
   10328                                                                       return 1359;
   10329                                                                     }
   10330                                                                 }
   10331                                                               else
   10332                                                                 {
   10333                                                                   /* 33222222222211111111110000000000
   10334                                                                      10987654321098765432109876543210
   10335                                                                      xxxxxxxxxxxxx101000110xx1x100110
   10336                                                                      fcvtzs.  */
   10337                                                                   return 1367;
   10338                                                                 }
   10339                                                             }
   10340                                                         }
   10341                                                       else
   10342                                                         {
   10343                                                           if (((word >> 19) & 0x1) == 0)
   10344                                                             {
   10345                                                               if (((word >> 20) & 0x1) == 0)
   10346                                                                 {
   10347                                                                   /* 33222222222211111111110000000000
   10348                                                                      10987654321098765432109876543210
   10349                                                                      xxxxxxxxxxxxx101001000xx1x100110
   10350                                                                      frinta.  */
   10351                                                                   return 1418;
   10352                                                                 }
   10353                                                               else
   10354                                                                 {
   10355                                                                   if (((word >> 22) & 0x1) == 0)
   10356                                                                     {
   10357                                                                       /* 33222222222211111111110000000000
   10358                                                                          10987654321098765432109876543210
   10359                                                                          xxxxxxxxxxxxx1010010100x1x100110
   10360                                                                          scvtf.  */
   10361                                                                       return 1750;
   10362                                                                     }
   10363                                                                   else
   10364                                                                     {
   10365                                                                       if (((word >> 23) & 0x1) == 0)
   10366                                                                         {
   10367                                                                           /* 33222222222211111111110000000000
   10368                                                                              10987654321098765432109876543210
   10369                                                                              xxxxxxxxxxxxx101001010101x100110
   10370                                                                              scvtf.  */
   10371                                                                           return 1749;
   10372                                                                         }
   10373                                                                       else
   10374                                                                         {
   10375                                                                           /* 33222222222211111111110000000000
   10376                                                                              10987654321098765432109876543210
   10377                                                                              xxxxxxxxxxxxx101001010111x100110
   10378                                                                              scvtf.  */
   10379                                                                           return 1753;
   10380                                                                         }
   10381                                                                     }
   10382                                                                 }
   10383                                                             }
   10384                                                           else
   10385                                                             {
   10386                                                               if (((word >> 20) & 0x1) == 0)
   10387                                                                 {
   10388                                                                   /* 33222222222211111111110000000000
   10389                                                                      10987654321098765432109876543210
   10390                                                                      xxxxxxxxxxxxx101001100xx1x100110
   10391                                                                      frecpx.  */
   10392                                                                   return 1417;
   10393                                                                 }
   10394                                                               else
   10395                                                                 {
   10396                                                                   if (((word >> 22) & 0x1) == 0)
   10397                                                                     {
   10398                                                                       /* 33222222222211111111110000000000
   10399                                                                          10987654321098765432109876543210
   10400                                                                          xxxxxxxxxxxxx1010011100x1x100110
   10401                                                                          fcvtzs.  */
   10402                                                                       return 1366;
   10403                                                                     }
   10404                                                                   else
   10405                                                                     {
   10406                                                                       if (((word >> 23) & 0x1) == 0)
   10407                                                                         {
   10408                                                                           /* 33222222222211111111110000000000
   10409                                                                              10987654321098765432109876543210
   10410                                                                              xxxxxxxxxxxxx101001110101x100110
   10411                                                                              fcvtzs.  */
   10412                                                                           return 1364;
   10413                                                                         }
   10414                                                                       else
   10415                                                                         {
   10416                                                                           /* 33222222222211111111110000000000
   10417                                                                              10987654321098765432109876543210
   10418                                                                              xxxxxxxxxxxxx101001110111x100110
   10419                                                                              fcvtzs.  */
   10420                                                                           return 1368;
   10421                                                                         }
   10422                                                                     }
   10423                                                                 }
   10424                                                             }
   10425                                                         }
   10426                                                     }
   10427                                                   else
   10428                                                     {
   10429                                                       if (((word >> 18) & 0x1) == 0)
   10430                                                         {
   10431                                                           if (((word >> 19) & 0x1) == 0)
   10432                                                             {
   10433                                                               if (((word >> 20) & 0x1) == 0)
   10434                                                                 {
   10435                                                                   /* 33222222222211111111110000000000
   10436                                                                      10987654321098765432109876543210
   10437                                                                      xxxxxxxxxxxxx101010000xx1x100110
   10438                                                                      frintm.  */
   10439                                                                   return 1420;
   10440                                                                 }
   10441                                                               else
   10442                                                                 {
   10443                                                                   /* 33222222222211111111110000000000
   10444                                                                      10987654321098765432109876543210
   10445                                                                      xxxxxxxxxxxxx101010010xx1x100110
   10446                                                                      scvtf.  */
   10447                                                                   return 1748;
   10448                                                                 }
   10449                                                             }
   10450                                                           else
   10451                                                             {
   10452                                                               if (((word >> 20) & 0x1) == 0)
   10453                                                                 {
   10454                                                                   /* 33222222222211111111110000000000
   10455                                                                      10987654321098765432109876543210
   10456                                                                      xxxxxxxxxxxxx101010100xx1x100110
   10457                                                                      fcvt.  */
   10458                                                                   return 1361;
   10459                                                                 }
   10460                                                               else
   10461                                                                 {
   10462                                                                   /* 33222222222211111111110000000000
   10463                                                                      10987654321098765432109876543210
   10464                                                                      xxxxxxxxxxxxx101010110xx1x100110
   10465                                                                      fcvtzs.  */
   10466                                                                   return 1363;
   10467                                                                 }
   10468                                                             }
   10469                                                         }
   10470                                                       else
   10471                                                         {
   10472                                                           if (((word >> 19) & 0x1) == 0)
   10473                                                             {
   10474                                                               if (((word >> 20) & 0x1) == 0)
   10475                                                                 {
   10476                                                                   /* 33222222222211111111110000000000
   10477                                                                      10987654321098765432109876543210
   10478                                                                      xxxxxxxxxxxxx101011000xx1x100110
   10479                                                                      frintx.  */
   10480                                                                   return 1423;
   10481                                                                 }
   10482                                                               else
   10483                                                                 {
   10484                                                                   if (((word >> 23) & 0x1) == 0)
   10485                                                                     {
   10486                                                                       /* 33222222222211111111110000000000
   10487                                                                          10987654321098765432109876543210
   10488                                                                          xxxxxxxxxxxxx101011010x01x100110
   10489                                                                          scvtf.  */
   10490                                                                       return 1752;
   10491                                                                     }
   10492                                                                   else
   10493                                                                     {
   10494                                                                       /* 33222222222211111111110000000000
   10495                                                                          10987654321098765432109876543210
   10496                                                                          xxxxxxxxxxxxx101011010x11x100110
   10497                                                                          scvtf.  */
   10498                                                                       return 1754;
   10499                                                                     }
   10500                                                                 }
   10501                                                             }
   10502                                                           else
   10503                                                             {
   10504                                                               if (((word >> 23) & 0x1) == 0)
   10505                                                                 {
   10506                                                                   /* 33222222222211111111110000000000
   10507                                                                      10987654321098765432109876543210
   10508                                                                      xxxxxxxxxxxxx1010111x0x01x100110
   10509                                                                      fcvtzs.  */
   10510                                                                   return 1365;
   10511                                                                 }
   10512                                                               else
   10513                                                                 {
   10514                                                                   /* 33222222222211111111110000000000
   10515                                                                      10987654321098765432109876543210
   10516                                                                      xxxxxxxxxxxxx1010111x0x11x100110
   10517                                                                      fcvtzs.  */
   10518                                                                   return 1369;
   10519                                                                 }
   10520                                                             }
   10521                                                         }
   10522                                                     }
   10523                                                 }
   10524                                               else
   10525                                                 {
   10526                                                   if (((word >> 17) & 0x1) == 0)
   10527                                                     {
   10528                                                       if (((word >> 18) & 0x1) == 0)
   10529                                                         {
   10530                                                           if (((word >> 19) & 0x1) == 0)
   10531                                                             {
   10532                                                               if (((word >> 20) & 0x1) == 0)
   10533                                                                 {
   10534                                                                   /* 33222222222211111111110000000000
   10535                                                                      10987654321098765432109876543210
   10536                                                                      xxxxxxxxxxxxx101100000xx1x100110
   10537                                                                      frintp.  */
   10538                                                                   return 1422;
   10539                                                                 }
   10540                                                               else
   10541                                                                 {
   10542                                                                   /* 33222222222211111111110000000000
   10543                                                                      10987654321098765432109876543210
   10544                                                                      xxxxxxxxxxxxx101100010xx1x100110
   10545                                                                      ucvtf.  */
   10546                                                                   return 1903;
   10547                                                                 }
   10548                                                             }
   10549                                                           else
   10550                                                             {
   10551                                                               if (((word >> 20) & 0x1) == 0)
   10552                                                                 {
   10553                                                                   if (((word >> 22) & 0x1) == 0)
   10554                                                                     {
   10555                                                                       /* 33222222222211111111110000000000
   10556                                                                          10987654321098765432109876543210
   10557                                                                          xxxxxxxxxxxxx1011001000x1x100110
   10558                                                                          fcvt.  */
   10559                                                                       return 1358;
   10560                                                                     }
   10561                                                                   else
   10562                                                                     {
   10563                                                                       /* 33222222222211111111110000000000
   10564                                                                          10987654321098765432109876543210
   10565                                                                          xxxxxxxxxxxxx1011001001x1x100110
   10566                                                                          fcvt.  */
   10567                                                                       return 1360;
   10568                                                                     }
   10569                                                                 }
   10570                                                               else
   10571                                                                 {
   10572                                                                   /* 33222222222211111111110000000000
   10573                                                                      10987654321098765432109876543210
   10574                                                                      xxxxxxxxxxxxx101100110xx1x100110
   10575                                                                      fcvtzu.  */
   10576                                                                   return 1374;
   10577                                                                 }
   10578                                                             }
   10579                                                         }
   10580                                                       else
   10581                                                         {
   10582                                                           if (((word >> 19) & 0x1) == 0)
   10583                                                             {
   10584                                                               if (((word >> 22) & 0x1) == 0)
   10585                                                                 {
   10586                                                                   /* 33222222222211111111110000000000
   10587                                                                      10987654321098765432109876543210
   10588                                                                      xxxxxxxxxxxxx1011010x00x1x100110
   10589                                                                      ucvtf.  */
   10590                                                                   return 1902;
   10591                                                                 }
   10592                                                               else
   10593                                                                 {
   10594                                                                   if (((word >> 23) & 0x1) == 0)
   10595                                                                     {
   10596                                                                       /* 33222222222211111111110000000000
   10597                                                                          10987654321098765432109876543210
   10598                                                                          xxxxxxxxxxxxx1011010x0101x100110
   10599                                                                          ucvtf.  */
   10600                                                                       return 1901;
   10601                                                                     }
   10602                                                                   else
   10603                                                                     {
   10604                                                                       /* 33222222222211111111110000000000
   10605                                                                          10987654321098765432109876543210
   10606                                                                          xxxxxxxxxxxxx1011010x0111x100110
   10607                                                                          ucvtf.  */
   10608                                                                       return 1905;
   10609                                                                     }
   10610                                                                 }
   10611                                                             }
   10612                                                           else
   10613                                                             {
   10614                                                               if (((word >> 20) & 0x1) == 0)
   10615                                                                 {
   10616                                                                   /* 33222222222211111111110000000000
   10617                                                                      10987654321098765432109876543210
   10618                                                                      xxxxxxxxxxxxx101101100xx1x100110
   10619                                                                      fsqrt.  */
   10620                                                                   return 1428;
   10621                                                                 }
   10622                                                               else
   10623                                                                 {
   10624                                                                   if (((word >> 22) & 0x1) == 0)
   10625                                                                     {
   10626                                                                       /* 33222222222211111111110000000000
   10627                                                                          10987654321098765432109876543210
   10628                                                                          xxxxxxxxxxxxx1011011100x1x100110
   10629                                                                          fcvtzu.  */
   10630                                                                       return 1373;
   10631                                                                     }
   10632                                                                   else
   10633                                                                     {
   10634                                                                       if (((word >> 23) & 0x1) == 0)
   10635                                                                         {
   10636                                                                           /* 33222222222211111111110000000000
   10637                                                                              10987654321098765432109876543210
   10638                                                                              xxxxxxxxxxxxx101101110101x100110
   10639                                                                              fcvtzu.  */
   10640                                                                           return 1371;
   10641                                                                         }
   10642                                                                       else
   10643                                                                         {
   10644                                                                           /* 33222222222211111111110000000000
   10645                                                                              10987654321098765432109876543210
   10646                                                                              xxxxxxxxxxxxx101101110111x100110
   10647                                                                              fcvtzu.  */
   10648                                                                           return 1375;
   10649                                                                         }
   10650                                                                     }
   10651                                                                 }
   10652                                                             }
   10653                                                         }
   10654                                                     }
   10655                                                   else
   10656                                                     {
   10657                                                       if (((word >> 18) & 0x1) == 0)
   10658                                                         {
   10659                                                           if (((word >> 19) & 0x1) == 0)
   10660                                                             {
   10661                                                               if (((word >> 20) & 0x1) == 0)
   10662                                                                 {
   10663                                                                   /* 33222222222211111111110000000000
   10664                                                                      10987654321098765432109876543210
   10665                                                                      xxxxxxxxxxxxx101110000xx1x100110
   10666                                                                      frintz.  */
   10667                                                                   return 1424;
   10668                                                                 }
   10669                                                               else
   10670                                                                 {
   10671                                                                   /* 33222222222211111111110000000000
   10672                                                                      10987654321098765432109876543210
   10673                                                                      xxxxxxxxxxxxx101110010xx1x100110
   10674                                                                      ucvtf.  */
   10675                                                                   return 1900;
   10676                                                                 }
   10677                                                             }
   10678                                                           else
   10679                                                             {
   10680                                                               if (((word >> 20) & 0x1) == 0)
   10681                                                                 {
   10682                                                                   /* 33222222222211111111110000000000
   10683                                                                      10987654321098765432109876543210
   10684                                                                      xxxxxxxxxxxxx101110100xx1x100110
   10685                                                                      fcvt.  */
   10686                                                                   return 1362;
   10687                                                                 }
   10688                                                               else
   10689                                                                 {
   10690                                                                   /* 33222222222211111111110000000000
   10691                                                                      10987654321098765432109876543210
   10692                                                                      xxxxxxxxxxxxx101110110xx1x100110
   10693                                                                      fcvtzu.  */
   10694                                                                   return 1370;
   10695                                                                 }
   10696                                                             }
   10697                                                         }
   10698                                                       else
   10699                                                         {
   10700                                                           if (((word >> 19) & 0x1) == 0)
   10701                                                             {
   10702                                                               if (((word >> 20) & 0x1) == 0)
   10703                                                                 {
   10704                                                                   /* 33222222222211111111110000000000
   10705                                                                      10987654321098765432109876543210
   10706                                                                      xxxxxxxxxxxxx101111000xx1x100110
   10707                                                                      frinti.  */
   10708                                                                   return 1419;
   10709                                                                 }
   10710                                                               else
   10711                                                                 {
   10712                                                                   if (((word >> 23) & 0x1) == 0)
   10713                                                                     {
   10714                                                                       /* 33222222222211111111110000000000
   10715                                                                          10987654321098765432109876543210
   10716                                                                          xxxxxxxxxxxxx101111010x01x100110
   10717                                                                          ucvtf.  */
   10718                                                                       return 1904;
   10719                                                                     }
   10720                                                                   else
   10721                                                                     {
   10722                                                                       /* 33222222222211111111110000000000
   10723                                                                          10987654321098765432109876543210
   10724                                                                          xxxxxxxxxxxxx101111010x11x100110
   10725                                                                          ucvtf.  */
   10726                                                                       return 1906;
   10727                                                                     }
   10728                                                                 }
   10729                                                             }
   10730                                                           else
   10731                                                             {
   10732                                                               if (((word >> 23) & 0x1) == 0)
   10733                                                                 {
   10734                                                                   /* 33222222222211111111110000000000
   10735                                                                      10987654321098765432109876543210
   10736                                                                      xxxxxxxxxxxxx1011111x0x01x100110
   10737                                                                      fcvtzu.  */
   10738                                                                   return 1372;
   10739                                                                 }
   10740                                                               else
   10741                                                                 {
   10742                                                                   /* 33222222222211111111110000000000
   10743                                                                      10987654321098765432109876543210
   10744                                                                      xxxxxxxxxxxxx1011111x0x11x100110
   10745                                                                      fcvtzu.  */
   10746                                                                   return 1376;
   10747                                                                 }
   10748                                                             }
   10749                                                         }
   10750                                                     }
   10751                                                 }
   10752                                             }
   10753                                           else
   10754                                             {
   10755                                               if (((word >> 22) & 0x1) == 0)
   10756                                                 {
   10757                                                   if (((word >> 23) & 0x1) == 0)
   10758                                                     {
   10759                                                       /* 33222222222211111111110000000000
   10760                                                          10987654321098765432109876543210
   10761                                                          xxxxxxxxxxxxx101xxxxx0001x100111
   10762                                                          st1w.  */
   10763                                                       return 1838;
   10764                                                     }
   10765                                                   else
   10766                                                     {
   10767                                                       /* 33222222222211111111110000000000
   10768                                                          10987654321098765432109876543210
   10769                                                          xxxxxxxxxxxxx101xxxxx0011x100111
   10770                                                          st1d.  */
   10771                                                       return 1817;
   10772                                                     }
   10773                                                 }
   10774                                               else
   10775                                                 {
   10776                                                   if (((word >> 23) & 0x1) == 0)
   10777                                                     {
   10778                                                       /* 33222222222211111111110000000000
   10779                                                          10987654321098765432109876543210
   10780                                                          xxxxxxxxxxxxx101xxxxx0101x100111
   10781                                                          st1w.  */
   10782                                                       return 1845;
   10783                                                     }
   10784                                                   else
   10785                                                     {
   10786                                                       /* 33222222222211111111110000000000
   10787                                                          10987654321098765432109876543210
   10788                                                          xxxxxxxxxxxxx101xxxxx0111x100111
   10789                                                          st1d.  */
   10790                                                       return 1821;
   10791                                                     }
   10792                                                 }
   10793                                             }
   10794                                         }
   10795                                       else
   10796                                         {
   10797                                           if (((word >> 31) & 0x1) == 0)
   10798                                             {
   10799                                               /* 33222222222211111111110000000000
   10800                                                  10987654321098765432109876543210
   10801                                                  xxxxxxxxxxxxx111xxxxx0xx1x100110
   10802                                                  facgt.  */
   10803                                               return 1335;
   10804                                             }
   10805                                           else
   10806                                             {
   10807                                               if (((word >> 20) & 0x1) == 0)
   10808                                                 {
   10809                                                   /* 33222222222211111111110000000000
   10810                                                      10987654321098765432109876543210
   10811                                                      xxxxxxxxxxxxx111xxxx00xx1x100111
   10812                                                      st1w.  */
   10813                                                   return 1846;
   10814                                                 }
   10815                                               else
   10816                                                 {
   10817                                                   if (((word >> 22) & 0x1) == 0)
   10818                                                     {
   10819                                                       if (((word >> 23) & 0x1) == 0)
   10820                                                         {
   10821                                                           /* 33222222222211111111110000000000
   10822                                                              10987654321098765432109876543210
   10823                                                              xxxxxxxxxxxxx111xxxx10001x100111
   10824                                                              stnt1w.  */
   10825                                                           return 1880;
   10826                                                         }
   10827                                                       else
   10828                                                         {
   10829                                                           /* 33222222222211111111110000000000
   10830                                                              10987654321098765432109876543210
   10831                                                              xxxxxxxxxxxxx111xxxx10011x100111
   10832                                                              stnt1d.  */
   10833                                                           return 1876;
   10834                                                         }
   10835                                                     }
   10836                                                   else
   10837                                                     {
   10838                                                       if (((word >> 23) & 0x1) == 0)
   10839                                                         {
   10840                                                           /* 33222222222211111111110000000000
   10841                                                              10987654321098765432109876543210
   10842                                                              xxxxxxxxxxxxx111xxxx10101x100111
   10843                                                              st3w.  */
   10844                                                           return 1864;
   10845                                                         }
   10846                                                       else
   10847                                                         {
   10848                                                           /* 33222222222211111111110000000000
   10849                                                              10987654321098765432109876543210
   10850                                                              xxxxxxxxxxxxx111xxxx10111x100111
   10851                                                              st3d.  */
   10852                                                           return 1860;
   10853                                                         }
   10854                                                     }
   10855                                                 }
   10856                                             }
   10857                                         }
   10858                                     }
   10859                                 }
   10860                             }
   10861                           else
   10862                             {
   10863                               if (((word >> 30) & 0x1) == 0)
   10864                                 {
   10865                                   if (((word >> 14) & 0x1) == 0)
   10866                                     {
   10867                                       if (((word >> 20) & 0x1) == 0)
   10868                                         {
   10869                                           if (((word >> 31) & 0x1) == 0)
   10870                                             {
   10871                                               if (((word >> 16) & 0x1) == 0)
   10872                                                 {
   10873                                                   if (((word >> 17) & 0x1) == 0)
   10874                                                     {
   10875                                                       if (((word >> 18) & 0x1) == 0)
   10876                                                         {
   10877                                                           if (((word >> 19) & 0x1) == 0)
   10878                                                             {
   10879                                                               /* 33222222222211111111110000000000
   10880                                                                  10987654321098765432109876543210
   10881                                                                  xxxxxxxxxxxxxx01000001xx1x100100
   10882                                                                  cntp.  */
   10883                                                               return 1304;
   10884                                                             }
   10885                                                           else
   10886                                                             {
   10887                                                               if (((word >> 10) & 0x1) == 0)
   10888                                                                 {
   10889                                                                   if (((word >> 11) & 0x1) == 0)
   10890                                                                     {
   10891                                                                       if (((word >> 12) & 0x1) == 0)
   10892                                                                         {
   10893                                                                           /* 33222222222211111111110000000000
   10894                                                                              10987654321098765432109876543210
   10895                                                                              xxxxxxxxxx000x01000101xx1x100100
   10896                                                                              sqincp.  */
   10897                                                                           return 1795;
   10898                                                                         }
   10899                                                                       else
   10900                                                                         {
   10901                                                                           /* 33222222222211111111110000000000
   10902                                                                              10987654321098765432109876543210
   10903                                                                              xxxxxxxxxx001x01000101xx1x100100
   10904                                                                              wrffr.  */
   10905                                                                           return 1968;
   10906                                                                         }
   10907                                                                     }
   10908                                                                   else
   10909                                                                     {
   10910                                                                       /* 33222222222211111111110000000000
   10911                                                                          10987654321098765432109876543210
   10912                                                                          xxxxxxxxxx01xx01000101xx1x100100
   10913                                                                          sqincp.  */
   10914                                                                       return 1797;
   10915                                                                     }
   10916                                                                 }
   10917                                                               else
   10918                                                                 {
   10919                                                                   /* 33222222222211111111110000000000
   10920                                                                      10987654321098765432109876543210
   10921                                                                      xxxxxxxxxx1xxx01000101xx1x100100
   10922                                                                      sqincp.  */
   10923                                                                   return 1796;
   10924                                                                 }
   10925                                                             }
   10926                                                         }
   10927                                                       else
   10928                                                         {
   10929                                                           if (((word >> 11) & 0x1) == 0)
   10930                                                             {
   10931                                                               if (((word >> 12) & 0x1) == 0)
   10932                                                                 {
   10933                                                                   /* 33222222222211111111110000000000
   10934                                                                      10987654321098765432109876543210
   10935                                                                      xxxxxxxxxxx00x01001x01xx1x100100
   10936                                                                      incp.  */
   10937                                                                   return 1442;
   10938                                                                 }
   10939                                                               else
   10940                                                                 {
   10941                                                                   /* 33222222222211111111110000000000
   10942                                                                      10987654321098765432109876543210
   10943                                                                      xxxxxxxxxxx01x01001x01xx1x100100
   10944                                                                      setffr.  */
   10945                                                                   return 1762;
   10946                                                                 }
   10947                                                             }
   10948                                                           else
   10949                                                             {
   10950                                                               /* 33222222222211111111110000000000
   10951                                                                  10987654321098765432109876543210
   10952                                                                  xxxxxxxxxxx1xx01001x01xx1x100100
   10953                                                                  incp.  */
   10954                                                               return 1443;
   10955                                                             }
   10956                                                         }
   10957                                                     }
   10958                                                   else
   10959                                                     {
   10960                                                       if (((word >> 10) & 0x1) == 0)
   10961                                                         {
   10962                                                           if (((word >> 11) & 0x1) == 0)
   10963                                                             {
   10964                                                               /* 33222222222211111111110000000000
   10965                                                                  10987654321098765432109876543210
   10966                                                                  xxxxxxxxxx00xx0101xx01xx1x100100
   10967                                                                  sqdecp.  */
   10968                                                               return 1781;
   10969                                                             }
   10970                                                           else
   10971                                                             {
   10972                                                               /* 33222222222211111111110000000000
   10973                                                                  10987654321098765432109876543210
   10974                                                                  xxxxxxxxxx01xx0101xx01xx1x100100
   10975                                                                  sqdecp.  */
   10976                                                               return 1783;
   10977                                                             }
   10978                                                         }
   10979                                                       else
   10980                                                         {
   10981                                                           /* 33222222222211111111110000000000
   10982                                                              10987654321098765432109876543210
   10983                                                              xxxxxxxxxx1xxx0101xx01xx1x100100
   10984                                                              sqdecp.  */
   10985                                                           return 1782;
   10986                                                         }
   10987                                                     }
   10988                                                 }
   10989                                               else
   10990                                                 {
   10991                                                   if (((word >> 10) & 0x1) == 0)
   10992                                                     {
   10993                                                       if (((word >> 11) & 0x1) == 0)
   10994                                                         {
   10995                                                           if (((word >> 17) & 0x1) == 0)
   10996                                                             {
   10997                                                               if (((word >> 18) & 0x1) == 0)
   10998                                                                 {
   10999                                                                   /* 33222222222211111111110000000000
   11000                                                                      10987654321098765432109876543210
   11001                                                                      xxxxxxxxxx00xx01100x01xx1x100100
   11002                                                                      uqincp.  */
   11003                                                                   return 1943;
   11004                                                                 }
   11005                                                               else
   11006                                                                 {
   11007                                                                   /* 33222222222211111111110000000000
   11008                                                                      10987654321098765432109876543210
   11009                                                                      xxxxxxxxxx00xx01101x01xx1x100100
   11010                                                                      decp.  */
   11011                                                                   return 1317;
   11012                                                                 }
   11013                                                             }
   11014                                                           else
   11015                                                             {
   11016                                                               /* 33222222222211111111110000000000
   11017                                                                  10987654321098765432109876543210
   11018                                                                  xxxxxxxxxx00xx0111xx01xx1x100100
   11019                                                                  uqdecp.  */
   11020                                                               return 1929;
   11021                                                             }
   11022                                                         }
   11023                                                       else
   11024                                                         {
   11025                                                           if (((word >> 17) & 0x1) == 0)
   11026                                                             {
   11027                                                               if (((word >> 18) & 0x1) == 0)
   11028                                                                 {
   11029                                                                   /* 33222222222211111111110000000000
   11030                                                                      10987654321098765432109876543210
   11031                                                                      xxxxxxxxxx01xx01100x01xx1x100100
   11032                                                                      uqincp.  */
   11033                                                                   return 1944;
   11034                                                                 }
   11035                                                               else
   11036                                                                 {
   11037                                                                   /* 33222222222211111111110000000000
   11038                                                                      10987654321098765432109876543210
   11039                                                                      xxxxxxxxxx01xx01101x01xx1x100100
   11040                                                                      decp.  */
   11041                                                                   return 1318;
   11042                                                                 }
   11043                                                             }
   11044                                                           else
   11045                                                             {
   11046                                                               /* 33222222222211111111110000000000
   11047                                                                  10987654321098765432109876543210
   11048                                                                  xxxxxxxxxx01xx0111xx01xx1x100100
   11049                                                                  uqdecp.  */
   11050                                                               return 1930;
   11051                                                             }
   11052                                                         }
   11053                                                     }
   11054                                                   else
   11055                                                     {
   11056                                                       if (((word >> 17) & 0x1) == 0)
   11057                                                         {
   11058                                                           /* 33222222222211111111110000000000
   11059                                                              10987654321098765432109876543210
   11060                                                              xxxxxxxxxx1xxx0110xx01xx1x100100
   11061                                                              uqincp.  */
   11062                                                           return 1945;
   11063                                                         }
   11064                                                       else
   11065                                                         {
   11066                                                           /* 33222222222211111111110000000000
   11067                                                              10987654321098765432109876543210
   11068                                                              xxxxxxxxxx1xxx0111xx01xx1x100100
   11069                                                              uqdecp.  */
   11070                                                           return 1931;
   11071                                                         }
   11072                                                     }
   11073                                                 }
   11074                                             }
   11075                                           else
   11076                                             {
   11077                                               if (((word >> 22) & 0x1) == 0)
   11078                                                 {
   11079                                                   if (((word >> 23) & 0x1) == 0)
   11080                                                     {
   11081                                                       /* 33222222222211111111110000000000
   11082                                                          10987654321098765432109876543210
   11083                                                          xxxxxxxxxxxxxx01xxxx01001x100101
   11084                                                          ld1sh.  */
   11085                                                       return 1535;
   11086                                                     }
   11087                                                   else
   11088                                                     {
   11089                                                       /* 33222222222211111111110000000000
   11090                                                          10987654321098765432109876543210
   11091                                                          xxxxxxxxxxxxxx01xxxx01011x100101
   11092                                                          ld1sb.  */
   11093                                                       return 1522;
   11094                                                     }
   11095                                                 }
   11096                                               else
   11097                                                 {
   11098                                                   if (((word >> 23) & 0x1) == 0)
   11099                                                     {
   11100                                                       /* 33222222222211111111110000000000
   11101                                                          10987654321098765432109876543210
   11102                                                          xxxxxxxxxxxxxx01xxxx01101x100101
   11103                                                          ld1w.  */
   11104                                                       return 1554;
   11105                                                     }
   11106                                                   else
   11107                                                     {
   11108                                                       /* 33222222222211111111110000000000
   11109                                                          10987654321098765432109876543210
   11110                                                          xxxxxxxxxxxxxx01xxxx01111x100101
   11111                                                          ld1d.  */
   11112                                                       return 1474;
   11113                                                     }
   11114                                                 }
   11115                                             }
   11116                                         }
   11117                                       else
   11118                                         {
   11119                                           if (((word >> 22) & 0x1) == 0)
   11120                                             {
   11121                                               if (((word >> 23) & 0x1) == 0)
   11122                                                 {
   11123                                                   /* 33222222222211111111110000000000
   11124                                                      10987654321098765432109876543210
   11125                                                      xxxxxxxxxxxxxx01xxxx11001x10010x
   11126                                                      ldnf1sh.  */
   11127                                                   return 1652;
   11128                                                 }
   11129                                               else
   11130                                                 {
   11131                                                   /* 33222222222211111111110000000000
   11132                                                      10987654321098765432109876543210
   11133                                                      xxxxxxxxxxxxxx01xxxx11011x10010x
   11134                                                      ldnf1sb.  */
   11135                                                   return 1649;
   11136                                                 }
   11137                                             }
   11138                                           else
   11139                                             {
   11140                                               if (((word >> 23) & 0x1) == 0)
   11141                                                 {
   11142                                                   /* 33222222222211111111110000000000
   11143                                                      10987654321098765432109876543210
   11144                                                      xxxxxxxxxxxxxx01xxxx11101x10010x
   11145                                                      ldnf1w.  */
   11146                                                   return 1655;
   11147                                                 }
   11148                                               else
   11149                                                 {
   11150                                                   /* 33222222222211111111110000000000
   11151                                                      10987654321098765432109876543210
   11152                                                      xxxxxxxxxxxxxx01xxxx11111x10010x
   11153                                                      ldnf1d.  */
   11154                                                   return 1644;
   11155                                                 }
   11156                                             }
   11157                                         }
   11158                                     }
   11159                                   else
   11160                                     {
   11161                                       if (((word >> 31) & 0x1) == 0)
   11162                                         {
   11163                                           if (((word >> 16) & 0x1) == 0)
   11164                                             {
   11165                                               if (((word >> 17) & 0x1) == 0)
   11166                                                 {
   11167                                                   if (((word >> 18) & 0x1) == 0)
   11168                                                     {
   11169                                                       if (((word >> 19) & 0x1) == 0)
   11170                                                         {
   11171                                                           if (((word >> 20) & 0x1) == 0)
   11172                                                             {
   11173                                                               /* 33222222222211111111110000000000
   11174                                                                  10987654321098765432109876543210
   11175                                                                  xxxxxxxxxxxxxx11000001xx1x100100
   11176                                                                  add.  */
   11177                                                               return 1231;
   11178                                                             }
   11179                                                           else
   11180                                                             {
   11181                                                               /* 33222222222211111111110000000000
   11182                                                                  10987654321098765432109876543210
   11183                                                                  xxxxxxxxxxxxxx11000011xx1x100100
   11184                                                                  mul.  */
   11185                                                               return 1684;
   11186                                                             }
   11187                                                         }
   11188                                                       else
   11189                                                         {
   11190                                                           if (((word >> 20) & 0x1) == 0)
   11191                                                             {
   11192                                                               /* 33222222222211111111110000000000
   11193                                                                  10987654321098765432109876543210
   11194                                                                  xxxxxxxxxxxxxx11000101xx1x100100
   11195                                                                  smax.  */
   11196                                                               return 1763;
   11197                                                             }
   11198                                                           else
   11199                                                             {
   11200                                                               /* 33222222222211111111110000000000
   11201                                                                  10987654321098765432109876543210
   11202                                                                  xxxxxxxxxxxxxx11000111xx1x100100
   11203                                                                  dup.  */
   11204                                                               return 1323;
   11205                                                             }
   11206                                                         }
   11207                                                     }
   11208                                                   else
   11209                                                     {
   11210                                                       /* 33222222222211111111110000000000
   11211                                                          10987654321098765432109876543210
   11212                                                          xxxxxxxxxxxxxx11001xx1xx1x100100
   11213                                                          sqadd.  */
   11214                                                       return 1772;
   11215                                                     }
   11216                                                 }
   11217                                               else
   11218                                                 {
   11219                                                   if (((word >> 18) & 0x1) == 0)
   11220                                                     {
   11221                                                       /* 33222222222211111111110000000000
   11222                                                          10987654321098765432109876543210
   11223                                                          xxxxxxxxxxxxxx11010xx1xx1x100100
   11224                                                          smin.  */
   11225                                                       return 1766;
   11226                                                     }
   11227                                                   else
   11228                                                     {
   11229                                                       /* 33222222222211111111110000000000
   11230                                                          10987654321098765432109876543210
   11231                                                          xxxxxxxxxxxxxx11011xx1xx1x100100
   11232                                                          sqsub.  */
   11233                                                       return 1802;
   11234                                                     }
   11235                                                 }
   11236                                             }
   11237                                           else
   11238                                             {
   11239                                               if (((word >> 17) & 0x1) == 0)
   11240                                                 {
   11241                                                   if (((word >> 18) & 0x1) == 0)
   11242                                                     {
   11243                                                       if (((word >> 19) & 0x1) == 0)
   11244                                                         {
   11245                                                           /* 33222222222211111111110000000000
   11246                                                              10987654321098765432109876543210
   11247                                                              xxxxxxxxxxxxxx111000x1xx1x100100
   11248                                                              sub.  */
   11249                                                           return 1884;
   11250                                                         }
   11251                                                       else
   11252                                                         {
   11253                                                           if (((word >> 20) & 0x1) == 0)
   11254                                                             {
   11255                                                               /* 33222222222211111111110000000000
   11256                                                                  10987654321098765432109876543210
   11257                                                                  xxxxxxxxxxxxxx11100101xx1x100100
   11258                                                                  umax.  */
   11259                                                               return 1912;
   11260                                                             }
   11261                                                           else
   11262                                                             {
   11263                                                               /* 33222222222211111111110000000000
   11264                                                                  10987654321098765432109876543210
   11265                                                                  xxxxxxxxxxxxxx11100111xx1x100100
   11266                                                                  fdup.  */
   11267                                                               return 1379;
   11268                                                             }
   11269                                                         }
   11270                                                     }
   11271                                                   else
   11272                                                     {
   11273                                                       /* 33222222222211111111110000000000
   11274                                                          10987654321098765432109876543210
   11275                                                          xxxxxxxxxxxxxx11101xx1xx1x100100
   11276                                                          uqadd.  */
   11277                                                       return 1920;
   11278                                                     }
   11279                                                 }
   11280                                               else
   11281                                                 {
   11282                                                   if (((word >> 18) & 0x1) == 0)
   11283                                                     {
   11284                                                       if (((word >> 19) & 0x1) == 0)
   11285                                                         {
   11286                                                           /* 33222222222211111111110000000000
   11287                                                              10987654321098765432109876543210
   11288                                                              xxxxxxxxxxxxxx111100x1xx1x100100
   11289                                                              subr.  */
   11290                                                           return 1886;
   11291                                                         }
   11292                                                       else
   11293                                                         {
   11294                                                           /* 33222222222211111111110000000000
   11295                                                              10987654321098765432109876543210
   11296                                                              xxxxxxxxxxxxxx111101x1xx1x100100
   11297                                                              umin.  */
   11298                                                           return 1915;
   11299                                                         }
   11300                                                     }
   11301                                                   else
   11302                                                     {
   11303                                                       /* 33222222222211111111110000000000
   11304                                                          10987654321098765432109876543210
   11305                                                          xxxxxxxxxxxxxx11111xx1xx1x100100
   11306                                                          uqsub.  */
   11307                                                       return 1950;
   11308                                                     }
   11309                                                 }
   11310                                             }
   11311                                         }
   11312                                       else
   11313                                         {
   11314                                           if (((word >> 13) & 0x1) == 0)
   11315                                             {
   11316                                               if (((word >> 22) & 0x1) == 0)
   11317                                                 {
   11318                                                   if (((word >> 23) & 0x1) == 0)
   11319                                                     {
   11320                                                       /* 33222222222211111111110000000000
   11321                                                          10987654321098765432109876543210
   11322                                                          xxxxxxxxxxxxx011xxxxx1001x100101
   11323                                                          ld2w.  */
   11324                                                       return 1562;
   11325                                                     }
   11326                                                   else
   11327                                                     {
   11328                                                       /* 33222222222211111111110000000000
   11329                                                          10987654321098765432109876543210
   11330                                                          xxxxxxxxxxxxx011xxxxx1011x100101
   11331                                                          ld2d.  */
   11332                                                       return 1558;
   11333                                                     }
   11334                                                 }
   11335                                               else
   11336                                                 {
   11337                                                   if (((word >> 23) & 0x1) == 0)
   11338                                                     {
   11339                                                       /* 33222222222211111111110000000000
   11340                                                          10987654321098765432109876543210
   11341                                                          xxxxxxxxxxxxx011xxxxx1101x100101
   11342                                                          ld4w.  */
   11343                                                       return 1578;
   11344                                                     }
   11345                                                   else
   11346                                                     {
   11347                                                       /* 33222222222211111111110000000000
   11348                                                          10987654321098765432109876543210
   11349                                                          xxxxxxxxxxxxx011xxxxx1111x100101
   11350                                                          ld4d.  */
   11351                                                       return 1574;
   11352                                                     }
   11353                                                 }
   11354                                             }
   11355                                           else
   11356                                             {
   11357                                               if (((word >> 22) & 0x1) == 0)
   11358                                                 {
   11359                                                   if (((word >> 23) & 0x1) == 0)
   11360                                                     {
   11361                                                       /* 33222222222211111111110000000000
   11362                                                          10987654321098765432109876543210
   11363                                                          xxxxxxxxxxxxx111xxxxx1001x100101
   11364                                                          ld2w.  */
   11365                                                       return 1563;
   11366                                                     }
   11367                                                   else
   11368                                                     {
   11369                                                       /* 33222222222211111111110000000000
   11370                                                          10987654321098765432109876543210
   11371                                                          xxxxxxxxxxxxx111xxxxx1011x100101
   11372                                                          ld2d.  */
   11373                                                       return 1559;
   11374                                                     }
   11375                                                 }
   11376                                               else
   11377                                                 {
   11378                                                   if (((word >> 23) & 0x1) == 0)
   11379                                                     {
   11380                                                       /* 33222222222211111111110000000000
   11381                                                          10987654321098765432109876543210
   11382                                                          xxxxxxxxxxxxx111xxxxx1101x100101
   11383                                                          ld4w.  */
   11384                                                       return 1579;
   11385                                                     }
   11386                                                   else
   11387                                                     {
   11388                                                       /* 33222222222211111111110000000000
   11389                                                          10987654321098765432109876543210
   11390                                                          xxxxxxxxxxxxx111xxxxx1111x100101
   11391                                                          ld4d.  */
   11392                                                       return 1575;
   11393                                                     }
   11394                                                 }
   11395                                             }
   11396                                         }
   11397                                     }
   11398                                 }
   11399                               else
   11400                                 {
   11401                                   if (((word >> 13) & 0x1) == 0)
   11402                                     {
   11403                                       if (((word >> 31) & 0x1) == 0)
   11404                                         {
   11405                                           if (((word >> 14) & 0x1) == 0)
   11406                                             {
   11407                                               /* 33222222222211111111110000000000
   11408                                                  10987654321098765432109876543210
   11409                                                  xxxxxxxxxxxxx001xxxxx1xx1x100110
   11410                                                  fmad.  */
   11411                                               return 1381;
   11412                                             }
   11413                                           else
   11414                                             {
   11415                                               /* 33222222222211111111110000000000
   11416                                                  10987654321098765432109876543210
   11417                                                  xxxxxxxxxxxxx011xxxxx1xx1x100110
   11418                                                  fnmad.  */
   11419                                               return 1411;
   11420                                             }
   11421                                         }
   11422                                       else
   11423                                         {
   11424                                           if (((word >> 22) & 0x1) == 0)
   11425                                             {
   11426                                               if (((word >> 23) & 0x1) == 0)
   11427                                                 {
   11428                                                   /* 33222222222211111111110000000000
   11429                                                      10987654321098765432109876543210
   11430                                                      xxxxxxxxxxxxx0x1xxxxx1001x100111
   11431                                                      st1w.  */
   11432                                                   return 1839;
   11433                                                 }
   11434                                               else
   11435                                                 {
   11436                                                   /* 33222222222211111111110000000000
   11437                                                      10987654321098765432109876543210
   11438                                                      xxxxxxxxxxxxx0x1xxxxx1011x100111
   11439                                                      st1d.  */
   11440                                                   return 1818;
   11441                                                 }
   11442                                             }
   11443                                           else
   11444                                             {
   11445                                               /* 33222222222211111111110000000000
   11446                                                  10987654321098765432109876543210
   11447                                                  xxxxxxxxxxxxx0x1xxxxx11x1x100111
   11448                                                  st1w.  */
   11449                                               return 1844;
   11450                                             }
   11451                                         }
   11452                                     }
   11453                                   else
   11454                                     {
   11455                                       if (((word >> 14) & 0x1) == 0)
   11456                                         {
   11457                                           if (((word >> 31) & 0x1) == 0)
   11458                                             {
   11459                                               /* 33222222222211111111110000000000
   11460                                                  10987654321098765432109876543210
   11461                                                  xxxxxxxxxxxxx101xxxxx1xx1x100110
   11462                                                  fmsb.  */
   11463                                               return 1402;
   11464                                             }
   11465                                           else
   11466                                             {
   11467                                               if (((word >> 22) & 0x1) == 0)
   11468                                                 {
   11469                                                   if (((word >> 23) & 0x1) == 0)
   11470                                                     {
   11471                                                       /* 33222222222211111111110000000000
   11472                                                          10987654321098765432109876543210
   11473                                                          xxxxxxxxxxxxx101xxxxx1001x100111
   11474                                                          st1w.  */
   11475                                                       return 1840;
   11476                                                     }
   11477                                                   else
   11478                                                     {
   11479                                                       /* 33222222222211111111110000000000
   11480                                                          10987654321098765432109876543210
   11481                                                          xxxxxxxxxxxxx101xxxxx1011x100111
   11482                                                          st1d.  */
   11483                                                       return 1819;
   11484                                                     }
   11485                                                 }
   11486                                               else
   11487                                                 {
   11488                                                   /* 33222222222211111111110000000000
   11489                                                      10987654321098765432109876543210
   11490                                                      xxxxxxxxxxxxx101xxxxx11x1x100111
   11491                                                      st1w.  */
   11492                                                   return 1847;
   11493                                                 }
   11494                                             }
   11495                                         }
   11496                                       else
   11497                                         {
   11498                                           if (((word >> 31) & 0x1) == 0)
   11499                                             {
   11500                                               /* 33222222222211111111110000000000
   11501                                                  10987654321098765432109876543210
   11502                                                  xxxxxxxxxxxxx111xxxxx1xx1x100110
   11503                                                  fnmsb.  */
   11504                                               return 1414;
   11505                                             }
   11506                                           else
   11507                                             {
   11508                                               if (((word >> 20) & 0x1) == 0)
   11509                                                 {
   11510                                                   if (((word >> 23) & 0x1) == 0)
   11511                                                     {
   11512                                                       /* 33222222222211111111110000000000
   11513                                                          10987654321098765432109876543210
   11514                                                          xxxxxxxxxxxxx111xxxx01x01x100111
   11515                                                          st1w.  */
   11516                                                       return 1848;
   11517                                                     }
   11518                                                   else
   11519                                                     {
   11520                                                       /* 33222222222211111111110000000000
   11521                                                          10987654321098765432109876543210
   11522                                                          xxxxxxxxxxxxx111xxxx01x11x100111
   11523                                                          st1d.  */
   11524                                                       return 1822;
   11525                                                     }
   11526                                                 }
   11527                                               else
   11528                                                 {
   11529                                                   if (((word >> 22) & 0x1) == 0)
   11530                                                     {
   11531                                                       if (((word >> 23) & 0x1) == 0)
   11532                                                         {
   11533                                                           /* 33222222222211111111110000000000
   11534                                                              10987654321098765432109876543210
   11535                                                              xxxxxxxxxxxxx111xxxx11001x100111
   11536                                                              st2w.  */
   11537                                                           return 1856;
   11538                                                         }
   11539                                                       else
   11540                                                         {
   11541                                                           /* 33222222222211111111110000000000
   11542                                                              10987654321098765432109876543210
   11543                                                              xxxxxxxxxxxxx111xxxx11011x100111
   11544                                                              st2d.  */
   11545                                                           return 1852;
   11546                                                         }
   11547                                                     }
   11548                                                   else
   11549                                                     {
   11550                                                       if (((word >> 23) & 0x1) == 0)
   11551                                                         {
   11552                                                           /* 33222222222211111111110000000000
   11553                                                              10987654321098765432109876543210
   11554                                                              xxxxxxxxxxxxx111xxxx11101x100111
   11555                                                              st4w.  */
   11556                                                           return 1872;
   11557                                                         }
   11558                                                       else
   11559                                                         {
   11560                                                           /* 33222222222211111111110000000000
   11561                                                              10987654321098765432109876543210
   11562                                                              xxxxxxxxxxxxx111xxxx11111x100111
   11563                                                              st4d.  */
   11564                                                           return 1868;
   11565                                                         }
   11566                                                     }
   11567                                                 }
   11568                                             }
   11569                                         }
   11570                                     }
   11571                                 }
   11572                             }
   11573                         }
   11574                     }
   11575                 }
   11576             }
   11577           else
   11578             {
   11579               if (((word >> 29) & 0x1) == 0)
   11580                 {
   11581                   if (((word >> 30) & 0x1) == 0)
   11582                     {
   11583                       if (((word >> 31) & 0x1) == 0)
   11584                         {
   11585                           /* 33222222222211111111110000000000
   11586                              10987654321098765432109876543210
   11587                              xxxxxxxxxxxxxxxxxxxxxxxxxx101000
   11588                              b.  */
   11589                           return 630;
   11590                         }
   11591                       else
   11592                         {
   11593                           /* 33222222222211111111110000000000
   11594                              10987654321098765432109876543210
   11595                              xxxxxxxxxxxxxxxxxxxxxxxxxx101001
   11596                              bl.  */
   11597                           return 631;
   11598                         }
   11599                     }
   11600                   else
   11601                     {
   11602                       if (((word >> 24) & 0x1) == 0)
   11603                         {
   11604                           if (((word >> 4) & 0x1) == 0)
   11605                             {
   11606                               if (((word >> 25) & 0x1) == 0)
   11607                                 {
   11608                                   if (((word >> 31) & 0x1) == 0)
   11609                                     {
   11610                                       /* 33222222222211111111110000000000
   11611                                          10987654321098765432109876543210
   11612                                          xxxx0xxxxxxxxxxxxxxxxxxx00101010
   11613                                          b.c.  */
   11614                                       return 651;
   11615                                     }
   11616                                   else
   11617                                     {
   11618                                       if (((word >> 0) & 0x1) == 0)
   11619                                         {
   11620                                           if (((word >> 1) & 0x1) == 0)
   11621                                             {
   11622                                               if (((word >> 21) & 0x1) == 0)
   11623                                                 {
   11624                                                   /* 33222222222211111111110000000000
   11625                                                      10987654321098765432109876543210
   11626                                                      00xx0xxxxxxxxxxxxxxxx0xx00101011
   11627                                                      hlt.  */
   11628                                                   return 742;
   11629                                                 }
   11630                                               else
   11631                                                 {
   11632                                                   /* 33222222222211111111110000000000
   11633                                                      10987654321098765432109876543210
   11634                                                      00xx0xxxxxxxxxxxxxxxx1xx00101011
   11635                                                      brk.  */
   11636                                                   return 741;
   11637                                                 }
   11638                                             }
   11639                                           else
   11640                                             {
   11641                                               if (((word >> 21) & 0x1) == 0)
   11642                                                 {
   11643                                                   /* 33222222222211111111110000000000
   11644                                                      10987654321098765432109876543210
   11645                                                      01xx0xxxxxxxxxxxxxxxx0xx00101011
   11646                                                      hvc.  */
   11647                                                   return 739;
   11648                                                 }
   11649                                               else
   11650                                                 {
   11651                                                   /* 33222222222211111111110000000000
   11652                                                      10987654321098765432109876543210
   11653                                                      01xx0xxxxxxxxxxxxxxxx1xx00101011
   11654                                                      dcps2.  */
   11655                                                   return 744;
   11656                                                 }
   11657                                             }
   11658                                         }
   11659                                       else
   11660                                         {
   11661                                           if (((word >> 1) & 0x1) == 0)
   11662                                             {
   11663                                               if (((word >> 21) & 0x1) == 0)
   11664                                                 {
   11665                                                   /* 33222222222211111111110000000000
   11666                                                      10987654321098765432109876543210
   11667                                                      10xx0xxxxxxxxxxxxxxxx0xx00101011
   11668                                                      svc.  */
   11669                                                   return 738;
   11670                                                 }
   11671                                               else
   11672                                                 {
   11673                                                   /* 33222222222211111111110000000000
   11674                                                      10987654321098765432109876543210
   11675                                                      10xx0xxxxxxxxxxxxxxxx1xx00101011
   11676                                                      dcps1.  */
   11677                                                   return 743;
   11678                                                 }
   11679                                             }
   11680                                           else
   11681                                             {
   11682                                               if (((word >> 21) & 0x1) == 0)
   11683                                                 {
   11684                                                   /* 33222222222211111111110000000000
   11685                                                      10987654321098765432109876543210
   11686                                                      11xx0xxxxxxxxxxxxxxxx0xx00101011
   11687                                                      smc.  */
   11688                                                   return 740;
   11689                                                 }
   11690                                               else
   11691                                                 {
   11692                                                   /* 33222222222211111111110000000000
   11693                                                      10987654321098765432109876543210
   11694                                                      11xx0xxxxxxxxxxxxxxxx1xx00101011
   11695                                                      dcps3.  */
   11696                                                   return 745;
   11697                                                 }
   11698                                             }
   11699                                         }
   11700                                     }
   11701                                 }
   11702                               else
   11703                                 {
   11704                                   if (((word >> 21) & 0x1) == 0)
   11705                                     {
   11706                                       if (((word >> 22) & 0x1) == 0)
   11707                                         {
   11708                                           if (((word >> 23) & 0x1) == 0)
   11709                                             {
   11710                                               /* 33222222222211111111110000000000
   11711                                                  10987654321098765432109876543210
   11712                                                  xxxx0xxxxxxxxxxxxxxxx0000110101x
   11713                                                  br.  */
   11714                                               return 632;
   11715                                             }
   11716                                           else
   11717                                             {
   11718                                               /* 33222222222211111111110000000000
   11719                                                  10987654321098765432109876543210
   11720                                                  xxxx0xxxxxxxxxxxxxxxx0010110101x
   11721                                                  eret.  */
   11722                                               return 635;
   11723                                             }
   11724                                         }
   11725                                       else
   11726                                         {
   11727                                           /* 33222222222211111111110000000000
   11728                                              10987654321098765432109876543210
   11729                                              xxxx0xxxxxxxxxxxxxxxx01x0110101x
   11730                                              ret.  */
   11731                                           return 634;
   11732                                         }
   11733                                     }
   11734                                   else
   11735                                     {
   11736                                       if (((word >> 23) & 0x1) == 0)
   11737                                         {
   11738                                           /* 33222222222211111111110000000000
   11739                                              10987654321098765432109876543210
   11740                                              xxxx0xxxxxxxxxxxxxxxx1x00110101x
   11741                                              blr.  */
   11742                                           return 633;
   11743                                         }
   11744                                       else
   11745                                         {
   11746                                           /* 33222222222211111111110000000000
   11747                                              10987654321098765432109876543210
   11748                                              xxxx0xxxxxxxxxxxxxxxx1x10110101x
   11749                                              drps.  */
   11750                                           return 636;
   11751                                         }
   11752                                     }
   11753                                 }
   11754                             }
   11755                           else
   11756                             {
   11757                               if (((word >> 10) & 0x1) == 0)
   11758                                 {
   11759                                   if (((word >> 21) & 0x1) == 0)
   11760                                     {
   11761                                       if (((word >> 22) & 0x1) == 0)
   11762                                         {
   11763                                           if (((word >> 23) & 0x1) == 0)
   11764                                             {
   11765                                               /* 33222222222211111111110000000000
   11766                                                  10987654321098765432109876543210
   11767                                                  xxxx1xxxxx0xxxxxxxxxx0000x10101x
   11768                                                  braaz.  */
   11769                                               return 641;
   11770                                             }
   11771                                           else
   11772                                             {
   11773                                               /* 33222222222211111111110000000000
   11774                                                  10987654321098765432109876543210
   11775                                                  xxxx1xxxxx0xxxxxxxxxx0010x10101x
   11776                                                  eretaa.  */
   11777                                               return 647;
   11778                                             }
   11779                                         }
   11780                                       else
   11781                                         {
   11782                                           /* 33222222222211111111110000000000
   11783                                              10987654321098765432109876543210
   11784                                              xxxx1xxxxx0xxxxxxxxxx01x0x10101x
   11785                                              retaa.  */
   11786                                           return 645;
   11787                                         }
   11788                                     }
   11789                                   else
   11790                                     {
   11791                                       /* 33222222222211111111110000000000
   11792                                          10987654321098765432109876543210
   11793                                          xxxx1xxxxx0xxxxxxxxxx1xx0x10101x
   11794                                          blraaz.  */
   11795                                       return 643;
   11796                                     }
   11797                                 }
   11798                               else
   11799                                 {
   11800                                   if (((word >> 21) & 0x1) == 0)
   11801                                     {
   11802                                       if (((word >> 22) & 0x1) == 0)
   11803                                         {
   11804                                           if (((word >> 23) & 0x1) == 0)
   11805                                             {
   11806                                               /* 33222222222211111111110000000000
   11807                                                  10987654321098765432109876543210
   11808                                                  xxxx1xxxxx1xxxxxxxxxx0000x10101x
   11809                                                  brabz.  */
   11810                                               return 642;
   11811                                             }
   11812                                           else
   11813                                             {
   11814                                               /* 33222222222211111111110000000000
   11815                                                  10987654321098765432109876543210
   11816                                                  xxxx1xxxxx1xxxxxxxxxx0010x10101x
   11817                                                  eretab.  */
   11818                                               return 648;
   11819                                             }
   11820                                         }
   11821                                       else
   11822                                         {
   11823                                           /* 33222222222211111111110000000000
   11824                                              10987654321098765432109876543210
   11825                                              xxxx1xxxxx1xxxxxxxxxx01x0x10101x
   11826                                              retab.  */
   11827                                           return 646;
   11828                                         }
   11829                                     }
   11830                                   else
   11831                                     {
   11832                                       /* 33222222222211111111110000000000
   11833                                          10987654321098765432109876543210
   11834                                          xxxx1xxxxx1xxxxxxxxxx1xx0x10101x
   11835                                          blrabz.  */
   11836                                       return 644;
   11837                                     }
   11838                                 }
   11839                             }
   11840                         }
   11841                       else
   11842                         {
   11843                           if (((word >> 21) & 0x1) == 0)
   11844                             {
   11845                               if (((word >> 25) & 0x1) == 0)
   11846                                 {
   11847                                   /* 33222222222211111111110000000000
   11848                                      10987654321098765432109876543210
   11849                                      xxxxxxxxxxxxxxxxxxxxx0xx1010101x
   11850                                      msr.  */
   11851                                   return 1157;
   11852                                 }
   11853                               else
   11854                                 {
   11855                                   if (((word >> 10) & 0x1) == 0)
   11856                                     {
   11857                                       /* 33222222222211111111110000000000
   11858                                          10987654321098765432109876543210
   11859                                          xxxxxxxxxx0xxxxxxxxxx0xx1110101x
   11860                                          braa.  */
   11861                                       return 637;
   11862                                     }
   11863                                   else
   11864                                     {
   11865                                       /* 33222222222211111111110000000000
   11866                                          10987654321098765432109876543210
   11867                                          xxxxxxxxxx1xxxxxxxxxx0xx1110101x
   11868                                          brab.  */
   11869                                       return 638;
   11870                                     }
   11871                                 }
   11872                             }
   11873                           else
   11874                             {
   11875                               if (((word >> 25) & 0x1) == 0)
   11876                                 {
   11877                                   /* 33222222222211111111110000000000
   11878                                      10987654321098765432109876543210
   11879                                      xxxxxxxxxxxxxxxxxxxxx1xx1010101x
   11880                                      sysl.  */
   11881                                   return 1182;
   11882                                 }
   11883                               else
   11884                                 {
   11885                                   if (((word >> 10) & 0x1) == 0)
   11886                                     {
   11887                                       /* 33222222222211111111110000000000
   11888                                          10987654321098765432109876543210
   11889                                          xxxxxxxxxx0xxxxxxxxxx1xx1110101x
   11890                                          blraa.  */
   11891                                       return 639;
   11892                                     }
   11893                                   else
   11894                                     {
   11895                                       /* 33222222222211111111110000000000
   11896                                          10987654321098765432109876543210
   11897                                          xxxxxxxxxx1xxxxxxxxxx1xx1110101x
   11898                                          blrab.  */
   11899                                       return 640;
   11900                                     }
   11901                                 }
   11902                             }
   11903                         }
   11904                     }
   11905                 }
   11906               else
   11907                 {
   11908                   if (((word >> 24) & 0x1) == 0)
   11909                     {
   11910                       if (((word >> 25) & 0x1) == 0)
   11911                         {
   11912                           /* 33222222222211111111110000000000
   11913                              10987654321098765432109876543210
   11914                              xxxxxxxxxxxxxxxxxxxxxxxx001011xx
   11915                              cbz.  */
   11916                           return 649;
   11917                         }
   11918                       else
   11919                         {
   11920                           /* 33222222222211111111110000000000
   11921                              10987654321098765432109876543210
   11922                              xxxxxxxxxxxxxxxxxxxxxxxx011011xx
   11923                              tbz.  */
   11924                           return 1192;
   11925                         }
   11926                     }
   11927                   else
   11928                     {
   11929                       if (((word >> 25) & 0x1) == 0)
   11930                         {
   11931                           /* 33222222222211111111110000000000
   11932                              10987654321098765432109876543210
   11933                              xxxxxxxxxxxxxxxxxxxxxxxx101011xx
   11934                              cbnz.  */
   11935                           return 650;
   11936                         }
   11937                       else
   11938                         {
   11939                           /* 33222222222211111111110000000000
   11940                              10987654321098765432109876543210
   11941                              xxxxxxxxxxxxxxxxxxxxxxxx111011xx
   11942                              tbnz.  */
   11943                           return 1193;
   11944                         }
   11945                     }
   11946                 }
   11947             }
   11948         }
   11949       else
   11950         {
   11951           if (((word >> 25) & 0x1) == 0)
   11952             {
   11953               if (((word >> 28) & 0x1) == 0)
   11954                 {
   11955                   if (((word >> 22) & 0x1) == 0)
   11956                     {
   11957                       if (((word >> 23) & 0x1) == 0)
   11958                         {
   11959                           if (((word >> 24) & 0x1) == 0)
   11960                             {
   11961                               if (((word >> 29) & 0x1) == 0)
   11962                                 {
   11963                                   /* 33222222222211111111110000000000
   11964                                      10987654321098765432109876543210
   11965                                      xxxxxxxxxxxxxxxxxxxxxx00001100xx
   11966                                      st4.  */
   11967                                   return 434;
   11968                                 }
   11969                               else
   11970                                 {
   11971                                   /* 33222222222211111111110000000000
   11972                                      10987654321098765432109876543210
   11973                                      xxxxxxxxxxxxxxxxxxxxxx00001101xx
   11974                                      stnp.  */
   11975                                   return 943;
   11976                                 }
   11977                             }
   11978                           else
   11979                             {
   11980                               if (((word >> 29) & 0x1) == 0)
   11981                                 {
   11982                                   if (((word >> 13) & 0x1) == 0)
   11983                                     {
   11984                                       if (((word >> 21) & 0x1) == 0)
   11985                                         {
   11986                                           /* 33222222222211111111110000000000
   11987                                              10987654321098765432109876543210
   11988                                              xxxxxxxxxxxxx0xxxxxxx000101100xx
   11989                                              st1.  */
   11990                                           return 450;
   11991                                         }
   11992                                       else
   11993                                         {
   11994                                           /* 33222222222211111111110000000000
   11995                                              10987654321098765432109876543210
   11996                                              xxxxxxxxxxxxx0xxxxxxx100101100xx
   11997                                              st2.  */
   11998                                           return 452;
   11999                                         }
   12000                                     }
   12001                                   else
   12002                                     {
   12003                                       if (((word >> 21) & 0x1) == 0)
   12004                                         {
   12005                                           /* 33222222222211111111110000000000
   12006                                              10987654321098765432109876543210
   12007                                              xxxxxxxxxxxxx1xxxxxxx000101100xx
   12008                                              st3.  */
   12009                                           return 451;
   12010                                         }
   12011                                       else
   12012                                         {
   12013                                           /* 33222222222211111111110000000000
   12014                                              10987654321098765432109876543210
   12015                                              xxxxxxxxxxxxx1xxxxxxx100101100xx
   12016                                              st4.  */
   12017                                           return 453;
   12018                                         }
   12019                                     }
   12020                                 }
   12021                               else
   12022                                 {
   12023                                   /* 33222222222211111111110000000000
   12024                                      10987654321098765432109876543210
   12025                                      xxxxxxxxxxxxxxxxxxxxxx00101101xx
   12026                                      stp.  */
   12027                                   return 947;
   12028                                 }
   12029                             }
   12030                         }
   12031                       else
   12032                         {
   12033                           if (((word >> 29) & 0x1) == 0)
   12034                             {
   12035                               if (((word >> 21) & 0x1) == 0)
   12036                                 {
   12037                                   if (((word >> 24) & 0x1) == 0)
   12038                                     {
   12039                                       /* 33222222222211111111110000000000
   12040                                          10987654321098765432109876543210
   12041                                          xxxxxxxxxxxxxxxxxxxxx001001100xx
   12042                                          st4.  */
   12043                                       return 442;
   12044                                     }
   12045                                   else
   12046                                     {
   12047                                       if (((word >> 13) & 0x1) == 0)
   12048                                         {
   12049                                           /* 33222222222211111111110000000000
   12050                                              10987654321098765432109876543210
   12051                                              xxxxxxxxxxxxx0xxxxxxx001101100xx
   12052                                              st1.  */
   12053                                           return 462;
   12054                                         }
   12055                                       else
   12056                                         {
   12057                                           /* 33222222222211111111110000000000
   12058                                              10987654321098765432109876543210
   12059                                              xxxxxxxxxxxxx1xxxxxxx001101100xx
   12060                                              st3.  */
   12061                                           return 463;
   12062                                         }
   12063                                     }
   12064                                 }
   12065                               else
   12066                                 {
   12067                                   if (((word >> 13) & 0x1) == 0)
   12068                                     {
   12069                                       /* 33222222222211111111110000000000
   12070                                          10987654321098765432109876543210
   12071                                          xxxxxxxxxxxxx0xxxxxxx101x01100xx
   12072                                          st2.  */
   12073                                       return 464;
   12074                                     }
   12075                                   else
   12076                                     {
   12077                                       /* 33222222222211111111110000000000
   12078                                          10987654321098765432109876543210
   12079                                          xxxxxxxxxxxxx1xxxxxxx101x01100xx
   12080                                          st4.  */
   12081                                       return 465;
   12082                                     }
   12083                                 }
   12084                             }
   12085                           else
   12086                             {
   12087                               /* 33222222222211111111110000000000
   12088                                  10987654321098765432109876543210
   12089                                  xxxxxxxxxxxxxxxxxxxxxx01x01101xx
   12090                                  stp.  */
   12091                               return 952;
   12092                             }
   12093                         }
   12094                     }
   12095                   else
   12096                     {
   12097                       if (((word >> 23) & 0x1) == 0)
   12098                         {
   12099                           if (((word >> 24) & 0x1) == 0)
   12100                             {
   12101                               if (((word >> 29) & 0x1) == 0)
   12102                                 {
   12103                                   /* 33222222222211111111110000000000
   12104                                      10987654321098765432109876543210
   12105                                      xxxxxxxxxxxxxxxxxxxxxx10001100xx
   12106                                      ld4.  */
   12107                                   return 438;
   12108                                 }
   12109                               else
   12110                                 {
   12111                                   /* 33222222222211111111110000000000
   12112                                      10987654321098765432109876543210
   12113                                      xxxxxxxxxxxxxxxxxxxxxx10001101xx
   12114                                      ldnp.  */
   12115                                   return 944;
   12116                                 }
   12117                             }
   12118                           else
   12119                             {
   12120                               if (((word >> 29) & 0x1) == 0)
   12121                                 {
   12122                                   if (((word >> 13) & 0x1) == 0)
   12123                                     {
   12124                                       if (((word >> 21) & 0x1) == 0)
   12125                                         {
   12126                                           /* 33222222222211111111110000000000
   12127                                              10987654321098765432109876543210
   12128                                              xxxxxxxxxxxxx0xxxxxxx010101100xx
   12129                                              ld1.  */
   12130                                           return 454;
   12131                                         }
   12132                                       else
   12133                                         {
   12134                                           /* 33222222222211111111110000000000
   12135                                              10987654321098765432109876543210
   12136                                              xxxxxxxxxxxxx0xxxxxxx110101100xx
   12137                                              ld2.  */
   12138                                           return 458;
   12139                                         }
   12140                                     }
   12141                                   else
   12142                                     {
   12143                                       if (((word >> 21) & 0x1) == 0)
   12144                                         {
   12145                                           /* 33222222222211111111110000000000
   12146                                              10987654321098765432109876543210
   12147                                              xxxxxxxxxxxxx1xxxxxxx010101100xx
   12148                                              ld3.  */
   12149                                           return 455;
   12150                                         }
   12151                                       else
   12152                                         {
   12153                                           /* 33222222222211111111110000000000
   12154                                              10987654321098765432109876543210
   12155                                              xxxxxxxxxxxxx1xxxxxxx110101100xx
   12156                                              ld4.  */
   12157                                           return 459;
   12158                                         }
   12159                                     }
   12160                                 }
   12161                               else
   12162                                 {
   12163                                   /* 33222222222211111111110000000000
   12164                                      10987654321098765432109876543210
   12165                                      xxxxxxxxxxxxxxxxxxxxxx10101101xx
   12166                                      ldp.  */
   12167                                   return 948;
   12168                                 }
   12169                             }
   12170                         }
   12171                       else
   12172                         {
   12173                           if (((word >> 29) & 0x1) == 0)
   12174                             {
   12175                               if (((word >> 21) & 0x1) == 0)
   12176                                 {
   12177                                   if (((word >> 24) & 0x1) == 0)
   12178                                     {
   12179                                       /* 33222222222211111111110000000000
   12180                                          10987654321098765432109876543210
   12181                                          xxxxxxxxxxxxxxxxxxxxx011001100xx
   12182                                          ld4.  */
   12183                                       return 446;
   12184                                     }
   12185                                   else
   12186                                     {
   12187                                       if (((word >> 13) & 0x1) == 0)
   12188                                         {
   12189                                           /* 33222222222211111111110000000000
   12190                                              10987654321098765432109876543210
   12191                                              xxxxxxxxxxxxx0xxxxxxx011101100xx
   12192                                              ld1.  */
   12193                                           return 466;
   12194                                         }
   12195                                       else
   12196                                         {
   12197                                           /* 33222222222211111111110000000000
   12198                                              10987654321098765432109876543210
   12199                                              xxxxxxxxxxxxx1xxxxxxx011101100xx
   12200                                              ld3.  */
   12201                                           return 467;
   12202                                         }
   12203                                     }
   12204                                 }
   12205                               else
   12206                                 {
   12207                                   if (((word >> 13) & 0x1) == 0)
   12208                                     {
   12209                                       /* 33222222222211111111110000000000
   12210                                          10987654321098765432109876543210
   12211                                          xxxxxxxxxxxxx0xxxxxxx111x01100xx
   12212                                          ld2.  */
   12213                                       return 470;
   12214                                     }
   12215                                   else
   12216                                     {
   12217                                       /* 33222222222211111111110000000000
   12218                                          10987654321098765432109876543210
   12219                                          xxxxxxxxxxxxx1xxxxxxx111x01100xx
   12220                                          ld4.  */
   12221                                       return 471;
   12222                                     }
   12223                                 }
   12224                             }
   12225                           else
   12226                             {
   12227                               /* 33222222222211111111110000000000
   12228                                  10987654321098765432109876543210
   12229                                  xxxxxxxxxxxxxxxxxxxxxx11x01101xx
   12230                                  ldp.  */
   12231                               return 953;
   12232                             }
   12233                         }
   12234                     }
   12235                 }
   12236               else
   12237                 {
   12238                   if (((word >> 24) & 0x1) == 0)
   12239                     {
   12240                       if (((word >> 29) & 0x1) == 0)
   12241                         {
   12242                           /* 33222222222211111111110000000000
   12243                              10987654321098765432109876543210
   12244                              xxxxxxxxxxxxxxxxxxxxxxxx001110xx
   12245                              ldr.  */
   12246                           return 956;
   12247                         }
   12248                       else
   12249                         {
   12250                           if (((word >> 10) & 0x1) == 0)
   12251                             {
   12252                               if (((word >> 11) & 0x1) == 0)
   12253                                 {
   12254                                   if (((word >> 22) & 0x1) == 0)
   12255                                     {
   12256                                       /* 33222222222211111111110000000000
   12257                                          10987654321098765432109876543210
   12258                                          xxxxxxxxxx00xxxxxxxxxx0x001111xx
   12259                                          stur.  */
   12260                                       return 899;
   12261                                     }
   12262                                   else
   12263                                     {
   12264                                       /* 33222222222211111111110000000000
   12265                                          10987654321098765432109876543210
   12266                                          xxxxxxxxxx00xxxxxxxxxx1x001111xx
   12267                                          ldur.  */
   12268                                       return 900;
   12269                                     }
   12270                                 }
   12271                               else
   12272                                 {
   12273                                   if (((word >> 22) & 0x1) == 0)
   12274                                     {
   12275                                       /* 33222222222211111111110000000000
   12276                                          10987654321098765432109876543210
   12277                                          xxxxxxxxxx01xxxxxxxxxx0x001111xx
   12278                                          str.  */
   12279                                       return 878;
   12280                                     }
   12281                                   else
   12282                                     {
   12283                                       /* 33222222222211111111110000000000
   12284                                          10987654321098765432109876543210
   12285                                          xxxxxxxxxx01xxxxxxxxxx1x001111xx
   12286                                          ldr.  */
   12287                                       return 879;
   12288                                     }
   12289                                 }
   12290                             }
   12291                           else
   12292                             {
   12293                               if (((word >> 22) & 0x1) == 0)
   12294                                 {
   12295                                   /* 33222222222211111111110000000000
   12296                                      10987654321098765432109876543210
   12297                                      xxxxxxxxxx1xxxxxxxxxxx0x001111xx
   12298                                      str.  */
   12299                                   return 855;
   12300                                 }
   12301                               else
   12302                                 {
   12303                                   /* 33222222222211111111110000000000
   12304                                      10987654321098765432109876543210
   12305                                      xxxxxxxxxx1xxxxxxxxxxx1x001111xx
   12306                                      ldr.  */
   12307                                   return 856;
   12308                                 }
   12309                             }
   12310                         }
   12311                     }
   12312                   else
   12313                     {
   12314                       if (((word >> 22) & 0x1) == 0)
   12315                         {
   12316                           /* 33222222222211111111110000000000
   12317                              10987654321098765432109876543210
   12318                              xxxxxxxxxxxxxxxxxxxxxx0x10111xxx
   12319                              str.  */
   12320                           return 866;
   12321                         }
   12322                       else
   12323                         {
   12324                           /* 33222222222211111111110000000000
   12325                              10987654321098765432109876543210
   12326                              xxxxxxxxxxxxxxxxxxxxxx1x10111xxx
   12327                              ldr.  */
   12328                           return 867;
   12329                         }
   12330                     }
   12331                 }
   12332             }
   12333           else
   12334             {
   12335               if (((word >> 24) & 0x1) == 0)
   12336                 {
   12337                   if (((word >> 21) & 0x1) == 0)
   12338                     {
   12339                       if (((word >> 28) & 0x1) == 0)
   12340                         {
   12341                           if (((word >> 10) & 0x1) == 0)
   12342                             {
   12343                               if (((word >> 29) & 0x1) == 0)
   12344                                 {
   12345                                   if (((word >> 11) & 0x1) == 0)
   12346                                     {
   12347                                       if (((word >> 12) & 0x1) == 0)
   12348                                         {
   12349                                           /* 33222222222211111111110000000000
   12350                                              10987654321098765432109876543210
   12351                                              xxxxxxxxxx000xxxxxxxx0xx011100xx
   12352                                              tbl.  */
   12353                                           return 414;
   12354                                         }
   12355                                       else
   12356                                         {
   12357                                           /* 33222222222211111111110000000000
   12358                                              10987654321098765432109876543210
   12359                                              xxxxxxxxxx001xxxxxxxx0xx011100xx
   12360                                              tbx.  */
   12361                                           return 415;
   12362                                         }
   12363                                     }
   12364                                   else
   12365                                     {
   12366                                       if (((word >> 12) & 0x1) == 0)
   12367                                         {
   12368                                           if (((word >> 14) & 0x1) == 0)
   12369                                             {
   12370                                               /* 33222222222211111111110000000000
   12371                                                  10987654321098765432109876543210
   12372                                                  xxxxxxxxxx010x0xxxxxx0xx011100xx
   12373                                                  trn1.  */
   12374                                               return 257;
   12375                                             }
   12376                                           else
   12377                                             {
   12378                                               /* 33222222222211111111110000000000
   12379                                                  10987654321098765432109876543210
   12380                                                  xxxxxxxxxx010x1xxxxxx0xx011100xx
   12381                                                  trn2.  */
   12382                                               return 260;
   12383                                             }
   12384                                         }
   12385                                       else
   12386                                         {
   12387                                           if (((word >> 13) & 0x1) == 0)
   12388                                             {
   12389                                               if (((word >> 14) & 0x1) == 0)
   12390                                                 {
   12391                                                   /* 33222222222211111111110000000000
   12392                                                      10987654321098765432109876543210
   12393                                                      xxxxxxxxxx01100xxxxxx0xx011100xx
   12394                                                      uzp1.  */
   12395                                                   return 256;
   12396                                                 }
   12397                                               else
   12398                                                 {
   12399                                                   /* 33222222222211111111110000000000
   12400                                                      10987654321098765432109876543210
   12401                                                      xxxxxxxxxx01101xxxxxx0xx011100xx
   12402                                                      uzp2.  */
   12403                                                   return 259;
   12404                                                 }
   12405                                             }
   12406                                           else
   12407                                             {
   12408                                               if (((word >> 14) & 0x1) == 0)
   12409                                                 {
   12410                                                   /* 33222222222211111111110000000000
   12411                                                      10987654321098765432109876543210
   12412                                                      xxxxxxxxxx01110xxxxxx0xx011100xx
   12413                                                      zip1.  */
   12414                                                   return 258;
   12415                                                 }
   12416                                               else
   12417                                                 {
   12418                                                   /* 33222222222211111111110000000000
   12419                                                      10987654321098765432109876543210
   12420                                                      xxxxxxxxxx01111xxxxxx0xx011100xx
   12421                                                      zip2.  */
   12422                                                   return 261;
   12423                                                 }
   12424                                             }
   12425                                         }
   12426                                     }
   12427                                 }
   12428                               else
   12429                                 {
   12430                                   /* 33222222222211111111110000000000
   12431                                      10987654321098765432109876543210
   12432                                      xxxxxxxxxx0xxxxxxxxxx0xx011101xx
   12433                                      ext.  */
   12434                                   return 130;
   12435                                 }
   12436                             }
   12437                           else
   12438                             {
   12439                               if (((word >> 15) & 0x1) == 0)
   12440                                 {
   12441                                   if (((word >> 22) & 0x1) == 0)
   12442                                     {
   12443                                       if (((word >> 29) & 0x1) == 0)
   12444                                         {
   12445                                           if (((word >> 11) & 0x1) == 0)
   12446                                             {
   12447                                               /* 33222222222211111111110000000000
   12448                                                  10987654321098765432109876543210
   12449                                                  xxxxxxxxxx10xxx0xxxxx00x011100xx
   12450                                                  dup.  */
   12451                                               return 147;
   12452                                             }
   12453                                           else
   12454                                             {
   12455                                               if (((word >> 12) & 0x1) == 0)
   12456                                                 {
   12457                                                   if (((word >> 13) & 0x1) == 0)
   12458                                                     {
   12459                                                       /* 33222222222211111111110000000000
   12460                                                          10987654321098765432109876543210
   12461                                                          xxxxxxxxxx1100x0xxxxx00x011100xx
   12462                                                          dup.  */
   12463                                                       return 148;
   12464                                                     }
   12465                                                   else
   12466                                                     {
   12467                                                       /* 33222222222211111111110000000000
   12468                                                          10987654321098765432109876543210
   12469                                                          xxxxxxxxxx1101x0xxxxx00x011100xx
   12470                                                          smov.  */
   12471                                                       return 149;
   12472                                                     }
   12473                                                 }
   12474                                               else
   12475                                                 {
   12476                                                   if (((word >> 13) & 0x1) == 0)
   12477                                                     {
   12478                                                       /* 33222222222211111111110000000000
   12479                                                          10987654321098765432109876543210
   12480                                                          xxxxxxxxxx1110x0xxxxx00x011100xx
   12481                                                          ins.  */
   12482                                                       return 152;
   12483                                                     }
   12484                                                   else
   12485                                                     {
   12486                                                       /* 33222222222211111111110000000000
   12487                                                          10987654321098765432109876543210
   12488                                                          xxxxxxxxxx1111x0xxxxx00x011100xx
   12489                                                          umov.  */
   12490                                                       return 150;
   12491                                                     }
   12492                                                 }
   12493                                             }
   12494                                         }
   12495                                       else
   12496                                         {
   12497                                           /* 33222222222211111111110000000000
   12498                                              10987654321098765432109876543210
   12499                                              xxxxxxxxxx1xxxx0xxxxx00x011101xx
   12500                                              ins.  */
   12501                                           return 154;
   12502                                         }
   12503                                     }
   12504                                   else
   12505                                     {
   12506                                       if (((word >> 11) & 0x1) == 0)
   12507                                         {
   12508                                           if (((word >> 12) & 0x1) == 0)
   12509                                             {
   12510                                               if (((word >> 13) & 0x1) == 0)
   12511                                                 {
   12512                                                   if (((word >> 23) & 0x1) == 0)
   12513                                                     {
   12514                                                       if (((word >> 29) & 0x1) == 0)
   12515                                                         {
   12516                                                           /* 33222222222211111111110000000000
   12517                                                              10987654321098765432109876543210
   12518                                                              xxxxxxxxxx1000x0xxxxx010011100xx
   12519                                                              fmaxnm.  */
   12520                                                           return 286;
   12521                                                         }
   12522                                                       else
   12523                                                         {
   12524                                                           /* 33222222222211111111110000000000
   12525                                                              10987654321098765432109876543210
   12526                                                              xxxxxxxxxx1000x0xxxxx010011101xx
   12527                                                              fmaxnmp.  */
   12528                                                           return 337;
   12529                                                         }
   12530                                                     }
   12531                                                   else
   12532                                                     {
   12533                                                       if (((word >> 29) & 0x1) == 0)
   12534                                                         {
   12535                                                           /* 33222222222211111111110000000000
   12536                                                              10987654321098765432109876543210
   12537                                                              xxxxxxxxxx1000x0xxxxx011011100xx
   12538                                                              fminnm.  */
   12539                                                           return 302;
   12540                                                         }
   12541                                                       else
   12542                                                         {
   12543                                                           /* 33222222222211111111110000000000
   12544                                                              10987654321098765432109876543210
   12545                                                              xxxxxxxxxx1000x0xxxxx011011101xx
   12546                                                              fminnmp.  */
   12547                                                           return 353;
   12548                                                         }
   12549                                                     }
   12550                                                 }
   12551                                               else
   12552                                                 {
   12553                                                   if (((word >> 23) & 0x1) == 0)
   12554                                                     {
   12555                                                       if (((word >> 29) & 0x1) == 0)
   12556                                                         {
   12557                                                           /* 33222222222211111111110000000000
   12558                                                              10987654321098765432109876543210
   12559                                                              xxxxxxxxxx1001x0xxxxx010011100xx
   12560                                                              fcmeq.  */
   12561                                                           return 294;
   12562                                                         }
   12563                                                       else
   12564                                                         {
   12565                                                           /* 33222222222211111111110000000000
   12566                                                              10987654321098765432109876543210
   12567                                                              xxxxxxxxxx1001x0xxxxx010011101xx
   12568                                                              fcmge.  */
   12569                                                           return 343;
   12570                                                         }
   12571                                                     }
   12572                                                   else
   12573                                                     {
   12574                                                       /* 33222222222211111111110000000000
   12575                                                          10987654321098765432109876543210
   12576                                                          xxxxxxxxxx1001x0xxxxx01101110xxx
   12577                                                          fcmgt.  */
   12578                                                       return 357;
   12579                                                     }
   12580                                                 }
   12581                                             }
   12582                                           else
   12583                                             {
   12584                                               if (((word >> 13) & 0x1) == 0)
   12585                                                 {
   12586                                                   if (((word >> 23) & 0x1) == 0)
   12587                                                     {
   12588                                                       if (((word >> 29) & 0x1) == 0)
   12589                                                         {
   12590                                                           /* 33222222222211111111110000000000
   12591                                                              10987654321098765432109876543210
   12592                                                              xxxxxxxxxx1010x0xxxxx010011100xx
   12593                                                              fadd.  */
   12594                                                           return 290;
   12595                                                         }
   12596                                                       else
   12597                                                         {
   12598                                                           /* 33222222222211111111110000000000
   12599                                                              10987654321098765432109876543210
   12600                                                              xxxxxxxxxx1010x0xxxxx010011101xx
   12601                                                              faddp.  */
   12602                                                           return 339;
   12603                                                         }
   12604                                                     }
   12605                                                   else
   12606                                                     {
   12607                                                       if (((word >> 29) & 0x1) == 0)
   12608                                                         {
   12609                                                           /* 33222222222211111111110000000000
   12610                                                              10987654321098765432109876543210
   12611                                                              xxxxxxxxxx1010x0xxxxx011011100xx
   12612                                                              fsub.  */
   12613                                                           return 306;
   12614                                                         }
   12615                                                       else
   12616                                                         {
   12617                                                           /* 33222222222211111111110000000000
   12618                                                              10987654321098765432109876543210
   12619                                                              xxxxxxxxxx1010x0xxxxx011011101xx
   12620                                                              fabd.  */
   12621                                                           return 355;
   12622                                                         }
   12623                                                     }
   12624                                                 }
   12625                                               else
   12626                                                 {
   12627                                                   if (((word >> 23) & 0x1) == 0)
   12628                                                     {
   12629                                                       if (((word >> 29) & 0x1) == 0)
   12630                                                         {
   12631                                                           /* 33222222222211111111110000000000
   12632                                                              10987654321098765432109876543210
   12633                                                              xxxxxxxxxx1011x0xxxxx010011100xx
   12634                                                              fmax.  */
   12635                                                           return 296;
   12636                                                         }
   12637                                                       else
   12638                                                         {
   12639                                                           /* 33222222222211111111110000000000
   12640                                                              10987654321098765432109876543210
   12641                                                              xxxxxxxxxx1011x0xxxxx010011101xx
   12642                                                              fmaxp.  */
   12643                                                           return 347;
   12644                                                         }
   12645                                                     }
   12646                                                   else
   12647                                                     {
   12648                                                       if (((word >> 29) & 0x1) == 0)
   12649                                                         {
   12650                                                           /* 33222222222211111111110000000000
   12651                                                              10987654321098765432109876543210
   12652                                                              xxxxxxxxxx1011x0xxxxx011011100xx
   12653                                                              fmin.  */
   12654                                                           return 308;
   12655                                                         }
   12656                                                       else
   12657                                                         {
   12658                                                           /* 33222222222211111111110000000000
   12659                                                              10987654321098765432109876543210
   12660                                                              xxxxxxxxxx1011x0xxxxx011011101xx
   12661                                                              fminp.  */
   12662                                                           return 361;
   12663                                                         }
   12664                                                     }
   12665                                                 }
   12666                                             }
   12667                                         }
   12668                                       else
   12669                                         {
   12670                                           if (((word >> 12) & 0x1) == 0)
   12671                                             {
   12672                                               if (((word >> 13) & 0x1) == 0)
   12673                                                 {
   12674                                                   if (((word >> 23) & 0x1) == 0)
   12675                                                     {
   12676                                                       /* 33222222222211111111110000000000
   12677                                                          10987654321098765432109876543210
   12678                                                          xxxxxxxxxx1100x0xxxxx01001110xxx
   12679                                                          fmla.  */
   12680                                                       return 288;
   12681                                                     }
   12682                                                   else
   12683                                                     {
   12684                                                       /* 33222222222211111111110000000000
   12685                                                          10987654321098765432109876543210
   12686                                                          xxxxxxxxxx1100x0xxxxx01101110xxx
   12687                                                          fmls.  */
   12688                                                       return 304;
   12689                                                     }
   12690                                                 }
   12691                                               else
   12692                                                 {
   12693                                                   if (((word >> 23) & 0x1) == 0)
   12694                                                     {
   12695                                                       /* 33222222222211111111110000000000
   12696                                                          10987654321098765432109876543210
   12697                                                          xxxxxxxxxx1101x0xxxxx01001110xxx
   12698                                                          facge.  */
   12699                                                       return 345;
   12700                                                     }
   12701                                                   else
   12702                                                     {
   12703                                                       /* 33222222222211111111110000000000
   12704                                                          10987654321098765432109876543210
   12705                                                          xxxxxxxxxx1101x0xxxxx01101110xxx
   12706                                                          facgt.  */
   12707                                                       return 359;
   12708                                                     }
   12709                                                 }
   12710                                             }
   12711                                           else
   12712                                             {
   12713                                               if (((word >> 13) & 0x1) == 0)
   12714                                                 {
   12715                                                   if (((word >> 29) & 0x1) == 0)
   12716                                                     {
   12717                                                       /* 33222222222211111111110000000000
   12718                                                          10987654321098765432109876543210
   12719                                                          xxxxxxxxxx1110x0xxxxx01x011100xx
   12720                                                          fmulx.  */
   12721                                                       return 292;
   12722                                                     }
   12723                                                   else
   12724                                                     {
   12725                                                       /* 33222222222211111111110000000000
   12726                                                          10987654321098765432109876543210
   12727                                                          xxxxxxxxxx1110x0xxxxx01x011101xx
   12728                                                          fmul.  */
   12729                                                       return 341;
   12730                                                     }
   12731                                                 }
   12732                                               else
   12733                                                 {
   12734                                                   if (((word >> 23) & 0x1) == 0)
   12735                                                     {
   12736                                                       if (((word >> 29) & 0x1) == 0)
   12737                                                         {
   12738                                                           /* 33222222222211111111110000000000
   12739                                                              10987654321098765432109876543210
   12740                                                              xxxxxxxxxx1111x0xxxxx010011100xx
   12741                                                              frecps.  */
   12742                                                           return 298;
   12743                                                         }
   12744                                                       else
   12745                                                         {
   12746                                                           /* 33222222222211111111110000000000
   12747                                                              10987654321098765432109876543210
   12748                                                              xxxxxxxxxx1111x0xxxxx010011101xx
   12749                                                              fdiv.  */
   12750                                                           return 349;
   12751                                                         }
   12752                                                     }
   12753                                                   else
   12754                                                     {
   12755                                                       /* 33222222222211111111110000000000
   12756                                                          10987654321098765432109876543210
   12757                                                          xxxxxxxxxx1111x0xxxxx01101110xxx
   12758                                                          frsqrts.  */
   12759                                                       return 310;
   12760                                                     }
   12761                                                 }
   12762                                             }
   12763                                         }
   12764                                     }
   12765                                 }
   12766                               else
   12767                                 {
   12768                                   if (((word >> 13) & 0x1) == 0)
   12769                                     {
   12770                                       if (((word >> 14) & 0x1) == 0)
   12771                                         {
   12772                                           if (((word >> 11) & 0x1) == 0)
   12773                                             {
   12774                                               /* 33222222222211111111110000000000
   12775                                                  10987654321098765432109876543210
   12776                                                  xxxxxxxxxx10x001xxxxx0xx01110xxx
   12777                                                  sqrdmlah.  */
   12778                                               return 364;
   12779                                             }
   12780                                           else
   12781                                             {
   12782                                               /* 33222222222211111111110000000000
   12783                                                  10987654321098765432109876543210
   12784                                                  xxxxxxxxxx11x001xxxxx0xx01110xxx
   12785                                                  sqrdmlsh.  */
   12786                                               return 365;
   12787                                             }
   12788                                         }
   12789                                       else
   12790                                         {
   12791                                           /* 33222222222211111111110000000000
   12792                                              10987654321098765432109876543210
   12793                                              xxxxxxxxxx1xx011xxxxx0xx01110xxx
   12794                                              fcmla.  */
   12795                                           return 366;
   12796                                         }
   12797                                     }
   12798                                   else
   12799                                     {
   12800                                       /* 33222222222211111111110000000000
   12801                                          10987654321098765432109876543210
   12802                                          xxxxxxxxxx1xx1x1xxxxx0xx01110xxx
   12803                                          fcadd.  */
   12804                                       return 367;
   12805                                     }
   12806                                 }
   12807                             }
   12808                         }
   12809                       else
   12810                         {
   12811                           if (((word >> 29) & 0x1) == 0)
   12812                             {
   12813                               if (((word >> 30) & 0x1) == 0)
   12814                                 {
   12815                                   if (((word >> 16) & 0x1) == 0)
   12816                                     {
   12817                                       if (((word >> 17) & 0x1) == 0)
   12818                                         {
   12819                                           /* 33222222222211111111110000000000
   12820                                              10987654321098765432109876543210
   12821                                              xxxxxxxxxxxxxxxx00xxx0xx0111100x
   12822                                              fcvtzs.  */
   12823                                           return 752;
   12824                                         }
   12825                                       else
   12826                                         {
   12827                                           /* 33222222222211111111110000000000
   12828                                              10987654321098765432109876543210
   12829                                              xxxxxxxxxxxxxxxx01xxx0xx0111100x
   12830                                              scvtf.  */
   12831                                           return 748;
   12832                                         }
   12833                                     }
   12834                                   else
   12835                                     {
   12836                                       if (((word >> 17) & 0x1) == 0)
   12837                                         {
   12838                                           /* 33222222222211111111110000000000
   12839                                              10987654321098765432109876543210
   12840                                              xxxxxxxxxxxxxxxx10xxx0xx0111100x
   12841                                              fcvtzu.  */
   12842                                           return 754;
   12843                                         }
   12844                                       else
   12845                                         {
   12846                                           /* 33222222222211111111110000000000
   12847                                              10987654321098765432109876543210
   12848                                              xxxxxxxxxxxxxxxx11xxx0xx0111100x
   12849                                              ucvtf.  */
   12850                                           return 750;
   12851                                         }
   12852                                     }
   12853                                 }
   12854                               else
   12855                                 {
   12856                                   if (((word >> 10) & 0x1) == 0)
   12857                                     {
   12858                                       if (((word >> 12) & 0x1) == 0)
   12859                                         {
   12860                                           if (((word >> 13) & 0x1) == 0)
   12861                                             {
   12862                                               if (((word >> 14) & 0x1) == 0)
   12863                                                 {
   12864                                                   /* 33222222222211111111110000000000
   12865                                                      10987654321098765432109876543210
   12866                                                      xxxxxxxxxx0x000xxxxxx0xx0111101x
   12867                                                      sha1c.  */
   12868                                                   return 672;
   12869                                                 }
   12870                                               else
   12871                                                 {
   12872                                                   /* 33222222222211111111110000000000
   12873                                                      10987654321098765432109876543210
   12874                                                      xxxxxxxxxx0x001xxxxxx0xx0111101x
   12875                                                      sha256h.  */
   12876                                                   return 676;
   12877                                                 }
   12878                                             }
   12879                                           else
   12880                                             {
   12881                                               if (((word >> 14) & 0x1) == 0)
   12882                                                 {
   12883                                                   /* 33222222222211111111110000000000
   12884                                                      10987654321098765432109876543210
   12885                                                      xxxxxxxxxx0x010xxxxxx0xx0111101x
   12886                                                      sha1m.  */
   12887                                                   return 674;
   12888                                                 }
   12889                                               else
   12890                                                 {
   12891                                                   /* 33222222222211111111110000000000
   12892                                                      10987654321098765432109876543210
   12893                                                      xxxxxxxxxx0x011xxxxxx0xx0111101x
   12894                                                      sha256su1.  */
   12895                                                   return 678;
   12896                                                 }
   12897                                             }
   12898                                         }
   12899                                       else
   12900                                         {
   12901                                           if (((word >> 13) & 0x1) == 0)
   12902                                             {
   12903                                               if (((word >> 14) & 0x1) == 0)
   12904                                                 {
   12905                                                   /* 33222222222211111111110000000000
   12906                                                      10987654321098765432109876543210
   12907                                                      xxxxxxxxxx0x100xxxxxx0xx0111101x
   12908                                                      sha1p.  */
   12909                                                   return 673;
   12910                                                 }
   12911                                               else
   12912                                                 {
   12913                                                   /* 33222222222211111111110000000000
   12914                                                      10987654321098765432109876543210
   12915                                                      xxxxxxxxxx0x101xxxxxx0xx0111101x
   12916                                                      sha256h2.  */
   12917                                                   return 677;
   12918                                                 }
   12919                                             }
   12920                                           else
   12921                                             {
   12922                                               /* 33222222222211111111110000000000
   12923                                                  10987654321098765432109876543210
   12924                                                  xxxxxxxxxx0x11xxxxxxx0xx0111101x
   12925                                                  sha1su0.  */
   12926                                               return 675;
   12927                                             }
   12928                                         }
   12929                                     }
   12930                                   else
   12931                                     {
   12932                                       if (((word >> 11) & 0x1) == 0)
   12933                                         {
   12934                                           if (((word >> 13) & 0x1) == 0)
   12935                                             {
   12936                                               /* 33222222222211111111110000000000
   12937                                                  10987654321098765432109876543210
   12938                                                  xxxxxxxxxx10x0xxxxxxx0xx0111101x
   12939                                                  dup.  */
   12940                                               return 529;
   12941                                             }
   12942                                           else
   12943                                             {
   12944                                               /* 33222222222211111111110000000000
   12945                                                  10987654321098765432109876543210
   12946                                                  xxxxxxxxxx10x1xxxxxxx0xx0111101x
   12947                                                  fcmeq.  */
   12948                                               return 550;
   12949                                             }
   12950                                         }
   12951                                       else
   12952                                         {
   12953                                           if (((word >> 13) & 0x1) == 0)
   12954                                             {
   12955                                               /* 33222222222211111111110000000000
   12956                                                  10987654321098765432109876543210
   12957                                                  xxxxxxxxxx11x0xxxxxxx0xx0111101x
   12958                                                  fmulx.  */
   12959                                               return 548;
   12960                                             }
   12961                                           else
   12962                                             {
   12963                                               if (((word >> 23) & 0x1) == 0)
   12964                                                 {
   12965                                                   /* 33222222222211111111110000000000
   12966                                                      10987654321098765432109876543210
   12967                                                      xxxxxxxxxx11x1xxxxxxx0x00111101x
   12968                                                      frecps.  */
   12969                                                   return 552;
   12970                                                 }
   12971                                               else
   12972                                                 {
   12973                                                   /* 33222222222211111111110000000000
   12974                                                      10987654321098765432109876543210
   12975                                                      xxxxxxxxxx11x1xxxxxxx0x10111101x
   12976                                                      frsqrts.  */
   12977                                                   return 554;
   12978                                                 }
   12979                                             }
   12980                                         }
   12981                                     }
   12982                                 }
   12983                             }
   12984                           else
   12985                             {
   12986                               if (((word >> 11) & 0x1) == 0)
   12987                                 {
   12988                                   if (((word >> 12) & 0x1) == 0)
   12989                                     {
   12990                                       if (((word >> 13) & 0x1) == 0)
   12991                                         {
   12992                                           /* 33222222222211111111110000000000
   12993                                              10987654321098765432109876543210
   12994                                              xxxxxxxxxxx000xxxxxxx0xx011111xx
   12995                                              sqrdmlah.  */
   12996                                           return 582;
   12997                                         }
   12998                                       else
   12999                                         {
   13000                                           if (((word >> 23) & 0x1) == 0)
   13001                                             {
   13002                                               /* 33222222222211111111110000000000
   13003                                                  10987654321098765432109876543210
   13004                                                  xxxxxxxxxxx001xxxxxxx0x0011111xx
   13005                                                  fcmge.  */
   13006                                               return 567;
   13007                                             }
   13008                                           else
   13009                                             {
   13010                                               /* 33222222222211111111110000000000
   13011                                                  10987654321098765432109876543210
   13012                                                  xxxxxxxxxxx001xxxxxxx0x1011111xx
   13013                                                  fcmgt.  */
   13014                                               return 573;
   13015                                             }
   13016                                         }
   13017                                     }
   13018                                   else
   13019                                     {
   13020                                       /* 33222222222211111111110000000000
   13021                                          10987654321098765432109876543210
   13022                                          xxxxxxxxxxx01xxxxxxxx0xx011111xx
   13023                                          fabd.  */
   13024                                       return 571;
   13025                                     }
   13026                                 }
   13027                               else
   13028                                 {
   13029                                   if (((word >> 13) & 0x1) == 0)
   13030                                     {
   13031                                       /* 33222222222211111111110000000000
   13032                                          10987654321098765432109876543210
   13033                                          xxxxxxxxxxx1x0xxxxxxx0xx011111xx
   13034                                          sqrdmlsh.  */
   13035                                       return 583;
   13036                                     }
   13037                                   else
   13038                                     {
   13039                                       if (((word >> 23) & 0x1) == 0)
   13040                                         {
   13041                                           /* 33222222222211111111110000000000
   13042                                              10987654321098765432109876543210
   13043                                              xxxxxxxxxxx1x1xxxxxxx0x0011111xx
   13044                                              facge.  */
   13045                                           return 569;
   13046                                         }
   13047                                       else
   13048                                         {
   13049                                           /* 33222222222211111111110000000000
   13050                                              10987654321098765432109876543210
   13051                                              xxxxxxxxxxx1x1xxxxxxx0x1011111xx
   13052                                              facgt.  */
   13053                                           return 575;
   13054                                         }
   13055                                     }
   13056                                 }
   13057                             }
   13058                         }
   13059                     }
   13060                   else
   13061                     {
   13062                       if (((word >> 10) & 0x1) == 0)
   13063                         {
   13064                           if (((word >> 11) & 0x1) == 0)
   13065                             {
   13066                               if (((word >> 12) & 0x1) == 0)
   13067                                 {
   13068                                   if (((word >> 13) & 0x1) == 0)
   13069                                     {
   13070                                       if (((word >> 14) & 0x1) == 0)
   13071                                         {
   13072                                           if (((word >> 15) & 0x1) == 0)
   13073                                             {
   13074                                               if (((word >> 28) & 0x1) == 0)
   13075                                                 {
   13076                                                   if (((word >> 29) & 0x1) == 0)
   13077                                                     {
   13078                                                       if (((word >> 30) & 0x1) == 0)
   13079                                                         {
   13080                                                           /* 33222222222211111111110000000000
   13081                                                              10987654321098765432109876543210
   13082                                                              xxxxxxxxxx000000xxxxx1xx0111000x
   13083                                                              saddl.  */
   13084                                                           return 42;
   13085                                                         }
   13086                                                       else
   13087                                                         {
   13088                                                           /* 33222222222211111111110000000000
   13089                                                              10987654321098765432109876543210
   13090                                                              xxxxxxxxxx000000xxxxx1xx0111001x
   13091                                                              saddl2.  */
   13092                                                           return 43;
   13093                                                         }
   13094                                                     }
   13095                                                   else
   13096                                                     {
   13097                                                       if (((word >> 30) & 0x1) == 0)
   13098                                                         {
   13099                                                           /* 33222222222211111111110000000000
   13100                                                              10987654321098765432109876543210
   13101                                                              xxxxxxxxxx000000xxxxx1xx0111010x
   13102                                                              uaddl.  */
   13103                                                           return 74;
   13104                                                         }
   13105                                                       else
   13106                                                         {
   13107                                                           /* 33222222222211111111110000000000
   13108                                                              10987654321098765432109876543210
   13109                                                              xxxxxxxxxx000000xxxxx1xx0111011x
   13110                                                              uaddl2.  */
   13111                                                           return 75;
   13112                                                         }
   13113                                                     }
   13114                                                 }
   13115                                               else
   13116                                                 {
   13117                                                   if (((word >> 16) & 0x1) == 0)
   13118                                                     {
   13119                                                       if (((word >> 17) & 0x1) == 0)
   13120                                                         {
   13121                                                           if (((word >> 18) & 0x1) == 0)
   13122                                                             {
   13123                                                               if (((word >> 19) & 0x1) == 0)
   13124                                                                 {
   13125                                                                   if (((word >> 20) & 0x1) == 0)
   13126                                                                     {
   13127                                                                       /* 33222222222211111111110000000000
   13128                                                                          10987654321098765432109876543210
   13129                                                                          xxxxxxxxxx000000000001xx01111xxx
   13130                                                                          fcvtns.  */
   13131                                                                       return 756;
   13132                                                                     }
   13133                                                                   else
   13134                                                                     {
   13135                                                                       /* 33222222222211111111110000000000
   13136                                                                          10987654321098765432109876543210
   13137                                                                          xxxxxxxxxx000000000011xx01111xxx
   13138                                                                          fcvtms.  */
   13139                                                                       return 776;
   13140                                                                     }
   13141                                                                 }
   13142                                                               else
   13143                                                                 {
   13144                                                                   if (((word >> 20) & 0x1) == 0)
   13145                                                                     {
   13146                                                                       /* 33222222222211111111110000000000
   13147                                                                          10987654321098765432109876543210
   13148                                                                          xxxxxxxxxx000000000101xx01111xxx
   13149                                                                          fcvtps.  */
   13150                                                                       return 772;
   13151                                                                     }
   13152                                                                   else
   13153                                                                     {
   13154                                                                       /* 33222222222211111111110000000000
   13155                                                                          10987654321098765432109876543210
   13156                                                                          xxxxxxxxxx000000000111xx01111xxx
   13157                                                                          fcvtzs.  */
   13158                                                                       return 780;
   13159                                                                     }
   13160                                                                 }
   13161                                                             }
   13162                                                           else
   13163                                                             {
   13164                                                               /* 33222222222211111111110000000000
   13165                                                                  10987654321098765432109876543210
   13166                                                                  xxxxxxxxxx000000001xx1xx01111xxx
   13167                                                                  fcvtas.  */
   13168                                                               return 764;
   13169                                                             }
   13170                                                         }
   13171                                                       else
   13172                                                         {
   13173                                                           if (((word >> 18) & 0x1) == 0)
   13174                                                             {
   13175                                                               /* 33222222222211111111110000000000
   13176                                                                  10987654321098765432109876543210
   13177                                                                  xxxxxxxxxx000000010xx1xx01111xxx
   13178                                                                  scvtf.  */
   13179                                                               return 760;
   13180                                                             }
   13181                                                           else
   13182                                                             {
   13183                                                               if (((word >> 19) & 0x1) == 0)
   13184                                                                 {
   13185                                                                   /* 33222222222211111111110000000000
   13186                                                                      10987654321098765432109876543210
   13187                                                                      xxxxxxxxxx0000000110x1xx01111xxx
   13188                                                                      fmov.  */
   13189                                                                   return 768;
   13190                                                                 }
   13191                                                               else
   13192                                                                 {
   13193                                                                   if (((word >> 20) & 0x1) == 0)
   13194                                                                     {
   13195                                                                       /* 33222222222211111111110000000000
   13196                                                                          10987654321098765432109876543210
   13197                                                                          xxxxxxxxxx000000011101xx01111xxx
   13198                                                                          fmov.  */
   13199                                                                       return 784;
   13200                                                                     }
   13201                                                                   else
   13202                                                                     {
   13203                                                                       /* 33222222222211111111110000000000
   13204                                                                          10987654321098765432109876543210
   13205                                                                          xxxxxxxxxx000000011111xx01111xxx
   13206                                                                          fjcvtzs.  */
   13207                                                                       return 786;
   13208                                                                     }
   13209                                                                 }
   13210                                                             }
   13211                                                         }
   13212                                                     }
   13213                                                   else
   13214                                                     {
   13215                                                       if (((word >> 17) & 0x1) == 0)
   13216                                                         {
   13217                                                           if (((word >> 18) & 0x1) == 0)
   13218                                                             {
   13219                                                               if (((word >> 19) & 0x1) == 0)
   13220                                                                 {
   13221                                                                   if (((word >> 20) & 0x1) == 0)
   13222                                                                     {
   13223                                                                       /* 33222222222211111111110000000000
   13224                                                                          10987654321098765432109876543210
   13225                                                                          xxxxxxxxxx000000100001xx01111xxx
   13226                                                                          fcvtnu.  */
   13227                                                                       return 758;
   13228                                                                     }
   13229                                                                   else
   13230                                                                     {
   13231                                                                       /* 33222222222211111111110000000000
   13232                                                                          10987654321098765432109876543210
   13233                                                                          xxxxxxxxxx000000100011xx01111xxx
   13234                                                                          fcvtmu.  */
   13235                                                                       return 778;
   13236                                                                     }
   13237                                                                 }
   13238                                                               else
   13239                                                                 {
   13240                                                                   if (((word >> 20) & 0x1) == 0)
   13241                                                                     {
   13242                                                                       /* 33222222222211111111110000000000
   13243                                                                          10987654321098765432109876543210
   13244                                                                          xxxxxxxxxx000000100101xx01111xxx
   13245                                                                          fcvtpu.  */
   13246                                                                       return 774;
   13247                                                                     }
   13248                                                                   else
   13249                                                                     {
   13250                                                                       /* 33222222222211111111110000000000
   13251                                                                          10987654321098765432109876543210
   13252                                                                          xxxxxxxxxx000000100111xx01111xxx
   13253                                                                          fcvtzu.  */
   13254                                                                       return 782;
   13255                                                                     }
   13256                                                                 }
   13257                                                             }
   13258                                                           else
   13259                                                             {
   13260                                                               /* 33222222222211111111110000000000
   13261                                                                  10987654321098765432109876543210
   13262                                                                  xxxxxxxxxx000000101xx1xx01111xxx
   13263                                                                  fcvtau.  */
   13264                                                               return 766;
   13265                                                             }
   13266                                                         }
   13267                                                       else
   13268                                                         {
   13269                                                           if (((word >> 18) & 0x1) == 0)
   13270                                                             {
   13271                                                               /* 33222222222211111111110000000000
   13272                                                                  10987654321098765432109876543210
   13273                                                                  xxxxxxxxxx000000110xx1xx01111xxx
   13274                                                                  ucvtf.  */
   13275                                                               return 762;
   13276                                                             }
   13277                                                           else
   13278                                                             {
   13279                                                               if (((word >> 19) & 0x1) == 0)
   13280                                                                 {
   13281                                                                   /* 33222222222211111111110000000000
   13282                                                                      10987654321098765432109876543210
   13283                                                                      xxxxxxxxxx0000001110x1xx01111xxx
   13284                                                                      fmov.  */
   13285                                                                   return 770;
   13286                                                                 }
   13287                                                               else
   13288                                                                 {
   13289                                                                   /* 33222222222211111111110000000000
   13290                                                                      10987654321098765432109876543210
   13291                                                                      xxxxxxxxxx0000001111x1xx01111xxx
   13292                                                                      fmov.  */
   13293                                                                   return 785;
   13294                                                                 }
   13295                                                             }
   13296                                                         }
   13297                                                     }
   13298                                                 }
   13299                                             }
   13300                                           else
   13301                                             {
   13302                                               if (((word >> 29) & 0x1) == 0)
   13303                                                 {
   13304                                                   if (((word >> 30) & 0x1) == 0)
   13305                                                     {
   13306                                                       /* 33222222222211111111110000000000
   13307                                                          10987654321098765432109876543210
   13308                                                          xxxxxxxxxx000001xxxxx1xx0111x00x
   13309                                                          smlal.  */
   13310                                                       return 58;
   13311                                                     }
   13312                                                   else
   13313                                                     {
   13314                                                       /* 33222222222211111111110000000000
   13315                                                          10987654321098765432109876543210
   13316                                                          xxxxxxxxxx000001xxxxx1xx0111x01x
   13317                                                          smlal2.  */
   13318                                                       return 59;
   13319                                                     }
   13320                                                 }
   13321                                               else
   13322                                                 {
   13323                                                   if (((word >> 30) & 0x1) == 0)
   13324                                                     {
   13325                                                       /* 33222222222211111111110000000000
   13326                                                          10987654321098765432109876543210
   13327                                                          xxxxxxxxxx000001xxxxx1xx0111x10x
   13328                                                          umlal.  */
   13329                                                       return 90;
   13330                                                     }
   13331                                                   else
   13332                                                     {
   13333                                                       /* 33222222222211111111110000000000
   13334                                                          10987654321098765432109876543210
   13335                                                          xxxxxxxxxx000001xxxxx1xx0111x11x
   13336                                                          umlal2.  */
   13337                                                       return 91;
   13338                                                     }
   13339                                                 }
   13340                                             }
   13341                                         }
   13342                                       else
   13343                                         {
   13344                                           if (((word >> 28) & 0x1) == 0)
   13345                                             {
   13346                                               if (((word >> 15) & 0x1) == 0)
   13347                                                 {
   13348                                                   if (((word >> 29) & 0x1) == 0)
   13349                                                     {
   13350                                                       if (((word >> 30) & 0x1) == 0)
   13351                                                         {
   13352                                                           /* 33222222222211111111110000000000
   13353                                                              10987654321098765432109876543210
   13354                                                              xxxxxxxxxx000010xxxxx1xx0111000x
   13355                                                              addhn.  */
   13356                                                           return 50;
   13357                                                         }
   13358                                                       else
   13359                                                         {
   13360                                                           /* 33222222222211111111110000000000
   13361                                                              10987654321098765432109876543210
   13362                                                              xxxxxxxxxx000010xxxxx1xx0111001x
   13363                                                              addhn2.  */
   13364                                                           return 51;
   13365                                                         }
   13366                                                     }
   13367                                                   else
   13368                                                     {
   13369                                                       if (((word >> 30) & 0x1) == 0)
   13370                                                         {
   13371                                                           /* 33222222222211111111110000000000
   13372                                                              10987654321098765432109876543210
   13373                                                              xxxxxxxxxx000010xxxxx1xx0111010x
   13374                                                              raddhn.  */
   13375                                                           return 82;
   13376                                                         }
   13377                                                       else
   13378                                                         {
   13379                                                           /* 33222222222211111111110000000000
   13380                                                              10987654321098765432109876543210
   13381                                                              xxxxxxxxxx000010xxxxx1xx0111011x
   13382                                                              raddhn2.  */
   13383                                                           return 83;
   13384                                                         }
   13385                                                     }
   13386                                                 }
   13387                                               else
   13388                                                 {
   13389                                                   if (((word >> 29) & 0x1) == 0)
   13390                                                     {
   13391                                                       if (((word >> 30) & 0x1) == 0)
   13392                                                         {
   13393                                                           /* 33222222222211111111110000000000
   13394                                                              10987654321098765432109876543210
   13395                                                              xxxxxxxxxx000011xxxxx1xx0111000x
   13396                                                              smull.  */
   13397                                                           return 66;
   13398                                                         }
   13399                                                       else
   13400                                                         {
   13401                                                           /* 33222222222211111111110000000000
   13402                                                              10987654321098765432109876543210
   13403                                                              xxxxxxxxxx000011xxxxx1xx0111001x
   13404                                                              smull2.  */
   13405                                                           return 67;
   13406                                                         }
   13407                                                     }
   13408                                                   else
   13409                                                     {
   13410                                                       if (((word >> 30) & 0x1) == 0)
   13411                                                         {
   13412                                                           /* 33222222222211111111110000000000
   13413                                                              10987654321098765432109876543210
   13414                                                              xxxxxxxxxx000011xxxxx1xx0111010x
   13415                                                              umull.  */
   13416                                                           return 94;
   13417                                                         }
   13418                                                       else
   13419                                                         {
   13420                                                           /* 33222222222211111111110000000000
   13421                                                              10987654321098765432109876543210
   13422                                                              xxxxxxxxxx000011xxxxx1xx0111011x
   13423                                                              umull2.  */
   13424                                                           return 95;
   13425                                                         }
   13426                                                     }
   13427                                                 }
   13428                                             }
   13429                                           else
   13430                                             {
   13431                                               if (((word >> 17) & 0x1) == 0)
   13432                                                 {
   13433                                                   if (((word >> 15) & 0x1) == 0)
   13434                                                     {
   13435                                                       if (((word >> 16) & 0x1) == 0)
   13436                                                         {
   13437                                                           if (((word >> 18) & 0x1) == 0)
   13438                                                             {
   13439                                                               /* 33222222222211111111110000000000
   13440                                                                  10987654321098765432109876543210
   13441                                                                  xxxxxxxxxx000010000xx1xx01111xxx
   13442                                                                  fmov.  */
   13443                                                               return 799;
   13444                                                             }
   13445                                                           else
   13446                                                             {
   13447                                                               /* 33222222222211111111110000000000
   13448                                                                  10987654321098765432109876543210
   13449                                                                  xxxxxxxxxx000010001xx1xx01111xxx
   13450                                                                  frintn.  */
   13451                                                               return 808;
   13452                                                             }
   13453                                                         }
   13454                                                       else
   13455                                                         {
   13456                                                           if (((word >> 18) & 0x1) == 0)
   13457                                                             {
   13458                                                               /* 33222222222211111111110000000000
   13459                                                                  10987654321098765432109876543210
   13460                                                                  xxxxxxxxxx000010100xx1xx01111xxx
   13461                                                                  fneg.  */
   13462                                                               return 803;
   13463                                                             }
   13464                                                           else
   13465                                                             {
   13466                                                               /* 33222222222211111111110000000000
   13467                                                                  10987654321098765432109876543210
   13468                                                                  xxxxxxxxxx000010101xx1xx01111xxx
   13469                                                                  frintm.  */
   13470                                                               return 812;
   13471                                                             }
   13472                                                         }
   13473                                                     }
   13474                                                   else
   13475                                                     {
   13476                                                       if (((word >> 16) & 0x1) == 0)
   13477                                                         {
   13478                                                           if (((word >> 18) & 0x1) == 0)
   13479                                                             {
   13480                                                               /* 33222222222211111111110000000000
   13481                                                                  10987654321098765432109876543210
   13482                                                                  xxxxxxxxxx000011000xx1xx01111xxx
   13483                                                                  fabs.  */
   13484                                                               return 801;
   13485                                                             }
   13486                                                           else
   13487                                                             {
   13488                                                               /* 33222222222211111111110000000000
   13489                                                                  10987654321098765432109876543210
   13490                                                                  xxxxxxxxxx000011001xx1xx01111xxx
   13491                                                                  frintp.  */
   13492                                                               return 810;
   13493                                                             }
   13494                                                         }
   13495                                                       else
   13496                                                         {
   13497                                                           if (((word >> 18) & 0x1) == 0)
   13498                                                             {
   13499                                                               /* 33222222222211111111110000000000
   13500                                                                  10987654321098765432109876543210
   13501                                                                  xxxxxxxxxx000011100xx1xx01111xxx
   13502                                                                  fsqrt.  */
   13503                                                               return 805;
   13504                                                             }
   13505                                                           else
   13506                                                             {
   13507                                                               /* 33222222222211111111110000000000
   13508                                                                  10987654321098765432109876543210
   13509                                                                  xxxxxxxxxx000011101xx1xx01111xxx
   13510                                                                  frintz.  */
   13511                                                               return 814;
   13512                                                             }
   13513                                                         }
   13514                                                     }
   13515                                                 }
   13516                                               else
   13517                                                 {
   13518                                                   if (((word >> 18) & 0x1) == 0)
   13519                                                     {
   13520                                                       /* 33222222222211111111110000000000
   13521                                                          10987654321098765432109876543210
   13522                                                          xxxxxxxxxx00001xx10xx1xx01111xxx
   13523                                                          fcvt.  */
   13524                                                       return 807;
   13525                                                     }
   13526                                                   else
   13527                                                     {
   13528                                                       if (((word >> 15) & 0x1) == 0)
   13529                                                         {
   13530                                                           if (((word >> 16) & 0x1) == 0)
   13531                                                             {
   13532                                                               /* 33222222222211111111110000000000
   13533                                                                  10987654321098765432109876543210
   13534                                                                  xxxxxxxxxx000010011xx1xx01111xxx
   13535                                                                  frinta.  */
   13536                                                               return 816;
   13537                                                             }
   13538                                                           else
   13539                                                             {
   13540                                                               /* 33222222222211111111110000000000
   13541                                                                  10987654321098765432109876543210
   13542                                                                  xxxxxxxxxx000010111xx1xx01111xxx
   13543                                                                  frintx.  */
   13544                                                               return 818;
   13545                                                             }
   13546                                                         }
   13547                                                       else
   13548                                                         {
   13549                                                           /* 33222222222211111111110000000000
   13550                                                              10987654321098765432109876543210
   13551                                                              xxxxxxxxxx000011x11xx1xx01111xxx
   13552                                                              frinti.  */
   13553                                                           return 820;
   13554                                                         }
   13555                                                     }
   13556                                                 }
   13557                                             }
   13558                                         }
   13559                                     }
   13560                                   else
   13561                                     {
   13562                                       if (((word >> 14) & 0x1) == 0)
   13563                                         {
   13564                                           if (((word >> 15) & 0x1) == 0)
   13565                                             {
   13566                                               if (((word >> 28) & 0x1) == 0)
   13567                                                 {
   13568                                                   if (((word >> 29) & 0x1) == 0)
   13569                                                     {
   13570                                                       if (((word >> 30) & 0x1) == 0)
   13571                                                         {
   13572                                                           /* 33222222222211111111110000000000
   13573                                                              10987654321098765432109876543210
   13574                                                              xxxxxxxxxx000100xxxxx1xx0111000x
   13575                                                              ssubl.  */
   13576                                                           return 46;
   13577                                                         }
   13578                                                       else
   13579                                                         {
   13580                                                           /* 33222222222211111111110000000000
   13581                                                              10987654321098765432109876543210
   13582                                                              xxxxxxxxxx000100xxxxx1xx0111001x
   13583                                                              ssubl2.  */
   13584                                                           return 47;
   13585                                                         }
   13586                                                     }
   13587                                                   else
   13588                                                     {
   13589                                                       if (((word >> 30) & 0x1) == 0)
   13590                                                         {
   13591                                                           /* 33222222222211111111110000000000
   13592                                                              10987654321098765432109876543210
   13593                                                              xxxxxxxxxx000100xxxxx1xx0111010x
   13594                                                              usubl.  */
   13595                                                           return 78;
   13596                                                         }
   13597                                                       else
   13598                                                         {
   13599                                                           /* 33222222222211111111110000000000
   13600                                                              10987654321098765432109876543210
   13601                                                              xxxxxxxxxx000100xxxxx1xx0111011x
   13602                                                              usubl2.  */
   13603                                                           return 79;
   13604                                                         }
   13605                                                     }
   13606                                                 }
   13607                                               else
   13608                                                 {
   13609                                                   if (((word >> 3) & 0x1) == 0)
   13610                                                     {
   13611                                                       if (((word >> 4) & 0x1) == 0)
   13612                                                         {
   13613                                                           /* 33222222222211111111110000000000
   13614                                                              10987654321098765432109876543210
   13615                                                              xxx00xxxxx000100xxxxx1xx01111xxx
   13616                                                              fcmp.  */
   13617                                                           return 791;
   13618                                                         }
   13619                                                       else
   13620                                                         {
   13621                                                           /* 33222222222211111111110000000000
   13622                                                              10987654321098765432109876543210
   13623                                                              xxx01xxxxx000100xxxxx1xx01111xxx
   13624                                                              fcmpe.  */
   13625                                                           return 793;
   13626                                                         }
   13627                                                     }
   13628                                                   else
   13629                                                     {
   13630                                                       if (((word >> 4) & 0x1) == 0)
   13631                                                         {
   13632                                                           /* 33222222222211111111110000000000
   13633                                                              10987654321098765432109876543210
   13634                                                              xxx10xxxxx000100xxxxx1xx01111xxx
   13635                                                              fcmp.  */
   13636                                                           return 795;
   13637                                                         }
   13638                                                       else
   13639                                                         {
   13640                                                           /* 33222222222211111111110000000000
   13641                                                              10987654321098765432109876543210
   13642                                                              xxx11xxxxx000100xxxxx1xx01111xxx
   13643                                                              fcmpe.  */
   13644                                                           return 797;
   13645                                                         }
   13646                                                     }
   13647                                                 }
   13648                                             }
   13649                                           else
   13650                                             {
   13651                                               if (((word >> 29) & 0x1) == 0)
   13652                                                 {
   13653                                                   if (((word >> 30) & 0x1) == 0)
   13654                                                     {
   13655                                                       /* 33222222222211111111110000000000
   13656                                                          10987654321098765432109876543210
   13657                                                          xxxxxxxxxx000101xxxxx1xx0111x00x
   13658                                                          smlsl.  */
   13659                                                       return 62;
   13660                                                     }
   13661                                                   else
   13662                                                     {
   13663                                                       /* 33222222222211111111110000000000
   13664                                                          10987654321098765432109876543210
   13665                                                          xxxxxxxxxx000101xxxxx1xx0111x01x
   13666                                                          smlsl2.  */
   13667                                                       return 63;
   13668                                                     }
   13669                                                 }
   13670                                               else
   13671                                                 {
   13672                                                   if (((word >> 30) & 0x1) == 0)
   13673                                                     {
   13674                                                       /* 33222222222211111111110000000000
   13675                                                          10987654321098765432109876543210
   13676                                                          xxxxxxxxxx000101xxxxx1xx0111x10x
   13677                                                          umlsl.  */
   13678                                                       return 92;
   13679                                                     }
   13680                                                   else
   13681                                                     {
   13682                                                       /* 33222222222211111111110000000000
   13683                                                          10987654321098765432109876543210
   13684                                                          xxxxxxxxxx000101xxxxx1xx0111x11x
   13685                                                          umlsl2.  */
   13686                                                       return 93;
   13687                                                     }
   13688                                                 }
   13689                                             }
   13690                                         }
   13691                                       else
   13692                                         {
   13693                                           if (((word >> 15) & 0x1) == 0)
   13694                                             {
   13695                                               if (((word >> 29) & 0x1) == 0)
   13696                                                 {
   13697                                                   if (((word >> 30) & 0x1) == 0)
   13698                                                     {
   13699                                                       /* 33222222222211111111110000000000
   13700                                                          10987654321098765432109876543210
   13701                                                          xxxxxxxxxx000110xxxxx1xx0111x00x
   13702                                                          subhn.  */
   13703                                                       return 54;
   13704                                                     }
   13705                                                   else
   13706                                                     {
   13707                                                       /* 33222222222211111111110000000000
   13708                                                          10987654321098765432109876543210
   13709                                                          xxxxxxxxxx000110xxxxx1xx0111x01x
   13710                                                          subhn2.  */
   13711                                                       return 55;
   13712                                                     }
   13713                                                 }
   13714                                               else
   13715                                                 {
   13716                                                   if (((word >> 30) & 0x1) == 0)
   13717                                                     {
   13718                                                       /* 33222222222211111111110000000000
   13719                                                          10987654321098765432109876543210
   13720                                                          xxxxxxxxxx000110xxxxx1xx0111x10x
   13721                                                          rsubhn.  */
   13722                                                       return 86;
   13723                                                     }
   13724                                                   else
   13725                                                     {
   13726                                                       /* 33222222222211111111110000000000
   13727                                                          10987654321098765432109876543210
   13728                                                          xxxxxxxxxx000110xxxxx1xx0111x11x
   13729                                                          rsubhn2.  */
   13730                                                       return 87;
   13731                                                     }
   13732                                                 }
   13733                                             }
   13734                                           else
   13735                                             {
   13736                                               if (((word >> 22) & 0x1) == 0)
   13737                                                 {
   13738                                                   if (((word >> 30) & 0x1) == 0)
   13739                                                     {
   13740                                                       /* 33222222222211111111110000000000
   13741                                                          10987654321098765432109876543210
   13742                                                          xxxxxxxxxx000111xxxxx10x0111xx0x
   13743                                                          pmull.  */
   13744                                                       return 70;
   13745                                                     }
   13746                                                   else
   13747                                                     {
   13748                                                       /* 33222222222211111111110000000000
   13749                                                          10987654321098765432109876543210
   13750                                                          xxxxxxxxxx000111xxxxx10x0111xx1x
   13751                                                          pmull2.  */
   13752                                                       return 72;
   13753                                                     }
   13754                                                 }
   13755                                               else
   13756                                                 {
   13757                                                   if (((word >> 30) & 0x1) == 0)
   13758                                                     {
   13759                                                       /* 33222222222211111111110000000000
   13760                                                          10987654321098765432109876543210
   13761                                                          xxxxxxxxxx000111xxxxx11x0111xx0x
   13762                                                          pmull.  */
   13763                                                       return 71;
   13764                                                     }
   13765                                                   else
   13766                                                     {
   13767                                                       /* 33222222222211111111110000000000
   13768                                                          10987654321098765432109876543210
   13769                                                          xxxxxxxxxx000111xxxxx11x0111xx1x
   13770                                                          pmull2.  */
   13771                                                       return 73;
   13772                                                     }
   13773                                                 }
   13774                                             }
   13775                                         }
   13776                                     }
   13777                                 }
   13778                               else
   13779                                 {
   13780                                   if (((word >> 28) & 0x1) == 0)
   13781                                     {
   13782                                       if (((word >> 13) & 0x1) == 0)
   13783                                         {
   13784                                           if (((word >> 14) & 0x1) == 0)
   13785                                             {
   13786                                               if (((word >> 15) & 0x1) == 0)
   13787                                                 {
   13788                                                   if (((word >> 29) & 0x1) == 0)
   13789                                                     {
   13790                                                       if (((word >> 30) & 0x1) == 0)
   13791                                                         {
   13792                                                           /* 33222222222211111111110000000000
   13793                                                              10987654321098765432109876543210
   13794                                                              xxxxxxxxxx001000xxxxx1xx0111000x
   13795                                                              saddw.  */
   13796                                                           return 44;
   13797                                                         }
   13798                                                       else
   13799                                                         {
   13800                                                           /* 33222222222211111111110000000000
   13801                                                              10987654321098765432109876543210
   13802                                                              xxxxxxxxxx001000xxxxx1xx0111001x
   13803                                                              saddw2.  */
   13804                                                           return 45;
   13805                                                         }
   13806                                                     }
   13807                                                   else
   13808                                                     {
   13809                                                       if (((word >> 30) & 0x1) == 0)
   13810                                                         {
   13811                                                           /* 33222222222211111111110000000000
   13812                                                              10987654321098765432109876543210
   13813                                                              xxxxxxxxxx001000xxxxx1xx0111010x
   13814                                                              uaddw.  */
   13815                                                           return 76;
   13816                                                         }
   13817                                                       else
   13818                                                         {
   13819                                                           /* 33222222222211111111110000000000
   13820                                                              10987654321098765432109876543210
   13821                                                              xxxxxxxxxx001000xxxxx1xx0111011x
   13822                                                              uaddw2.  */
   13823                                                           return 77;
   13824                                                         }
   13825                                                     }
   13826                                                 }
   13827                                               else
   13828                                                 {
   13829                                                   if (((word >> 30) & 0x1) == 0)
   13830                                                     {
   13831                                                       /* 33222222222211111111110000000000
   13832                                                          10987654321098765432109876543210
   13833                                                          xxxxxxxxxx001001xxxxx1xx01110x0x
   13834                                                          sqdmlal.  */
   13835                                                       return 60;
   13836                                                     }
   13837                                                   else
   13838                                                     {
   13839                                                       /* 33222222222211111111110000000000
   13840                                                          10987654321098765432109876543210
   13841                                                          xxxxxxxxxx001001xxxxx1xx01110x1x
   13842                                                          sqdmlal2.  */
   13843                                                       return 61;
   13844                                                     }
   13845                                                 }
   13846                                             }
   13847                                           else
   13848                                             {
   13849                                               if (((word >> 15) & 0x1) == 0)
   13850                                                 {
   13851                                                   if (((word >> 29) & 0x1) == 0)
   13852                                                     {
   13853                                                       if (((word >> 30) & 0x1) == 0)
   13854                                                         {
   13855                                                           /* 33222222222211111111110000000000
   13856                                                              10987654321098765432109876543210
   13857                                                              xxxxxxxxxx001010xxxxx1xx0111000x
   13858                                                              sabal.  */
   13859                                                           return 52;
   13860                                                         }
   13861                                                       else
   13862                                                         {
   13863                                                           /* 33222222222211111111110000000000
   13864                                                              10987654321098765432109876543210
   13865                                                              xxxxxxxxxx001010xxxxx1xx0111001x
   13866                                                              sabal2.  */
   13867                                                           return 53;
   13868                                                         }
   13869                                                     }
   13870                                                   else
   13871                                                     {
   13872                                                       if (((word >> 30) & 0x1) == 0)
   13873                                                         {
   13874                                                           /* 33222222222211111111110000000000
   13875                                                              10987654321098765432109876543210
   13876                                                              xxxxxxxxxx001010xxxxx1xx0111010x
   13877                                                              uabal.  */
   13878                                                           return 84;
   13879                                                         }
   13880                                                       else
   13881                                                         {
   13882                                                           /* 33222222222211111111110000000000
   13883                                                              10987654321098765432109876543210
   13884                                                              xxxxxxxxxx001010xxxxx1xx0111011x
   13885                                                              uabal2.  */
   13886                                                           return 85;
   13887                                                         }
   13888                                                     }
   13889                                                 }
   13890                                               else
   13891                                                 {
   13892                                                   if (((word >> 30) & 0x1) == 0)
   13893                                                     {
   13894                                                       /* 33222222222211111111110000000000
   13895                                                          10987654321098765432109876543210
   13896                                                          xxxxxxxxxx001011xxxxx1xx01110x0x
   13897                                                          sqdmull.  */
   13898                                                       return 68;
   13899                                                     }
   13900                                                   else
   13901                                                     {
   13902                                                       /* 33222222222211111111110000000000
   13903                                                          10987654321098765432109876543210
   13904                                                          xxxxxxxxxx001011xxxxx1xx01110x1x
   13905                                                          sqdmull2.  */
   13906                                                       return 69;
   13907                                                     }
   13908                                                 }
   13909                                             }
   13910                                         }
   13911                                       else
   13912                                         {
   13913                                           if (((word >> 14) & 0x1) == 0)
   13914                                             {
   13915                                               if (((word >> 15) & 0x1) == 0)
   13916                                                 {
   13917                                                   if (((word >> 29) & 0x1) == 0)
   13918                                                     {
   13919                                                       if (((word >> 30) & 0x1) == 0)
   13920                                                         {
   13921                                                           /* 33222222222211111111110000000000
   13922                                                              10987654321098765432109876543210
   13923                                                              xxxxxxxxxx001100xxxxx1xx0111000x
   13924                                                              ssubw.  */
   13925                                                           return 48;
   13926                                                         }
   13927                                                       else
   13928                                                         {
   13929                                                           /* 33222222222211111111110000000000
   13930                                                              10987654321098765432109876543210
   13931                                                              xxxxxxxxxx001100xxxxx1xx0111001x
   13932                                                              ssubw2.  */
   13933                                                           return 49;
   13934                                                         }
   13935                                                     }
   13936                                                   else
   13937                                                     {
   13938                                                       if (((word >> 30) & 0x1) == 0)
   13939                                                         {
   13940                                                           /* 33222222222211111111110000000000
   13941                                                              10987654321098765432109876543210
   13942                                                              xxxxxxxxxx001100xxxxx1xx0111010x
   13943                                                              usubw.  */
   13944                                                           return 80;
   13945                                                         }
   13946                                                       else
   13947                                                         {
   13948                                                           /* 33222222222211111111110000000000
   13949                                                              10987654321098765432109876543210
   13950                                                              xxxxxxxxxx001100xxxxx1xx0111011x
   13951                                                              usubw2.  */
   13952                                                           return 81;
   13953                                                         }
   13954                                                     }
   13955                                                 }
   13956                                               else
   13957                                                 {
   13958                                                   if (((word >> 30) & 0x1) == 0)
   13959                                                     {
   13960                                                       /* 33222222222211111111110000000000
   13961                                                          10987654321098765432109876543210
   13962                                                          xxxxxxxxxx001101xxxxx1xx01110x0x
   13963                                                          sqdmlsl.  */
   13964                                                       return 64;
   13965                                                     }
   13966                                                   else
   13967                                                     {
   13968                                                       /* 33222222222211111111110000000000
   13969                                                          10987654321098765432109876543210
   13970                                                          xxxxxxxxxx001101xxxxx1xx01110x1x
   13971                                                          sqdmlsl2.  */
   13972                                                       return 65;
   13973                                                     }
   13974                                                 }
   13975                                             }
   13976                                           else
   13977                                             {
   13978                                               if (((word >> 29) & 0x1) == 0)
   13979                                                 {
   13980                                                   if (((word >> 30) & 0x1) == 0)
   13981                                                     {
   13982                                                       /* 33222222222211111111110000000000
   13983                                                          10987654321098765432109876543210
   13984                                                          xxxxxxxxxx00111xxxxxx1xx0111000x
   13985                                                          sabdl.  */
   13986                                                       return 56;
   13987                                                     }
   13988                                                   else
   13989                                                     {
   13990                                                       /* 33222222222211111111110000000000
   13991                                                          10987654321098765432109876543210
   13992                                                          xxxxxxxxxx00111xxxxxx1xx0111001x
   13993                                                          sabdl2.  */
   13994                                                       return 57;
   13995                                                     }
   13996                                                 }
   13997                                               else
   13998                                                 {
   13999                                                   if (((word >> 30) & 0x1) == 0)
   14000                                                     {
   14001                                                       /* 33222222222211111111110000000000
   14002                                                          10987654321098765432109876543210
   14003                                                          xxxxxxxxxx00111xxxxxx1xx0111010x
   14004                                                          uabdl.  */
   14005                                                       return 88;
   14006                                                     }
   14007                                                   else
   14008                                                     {
   14009                                                       /* 33222222222211111111110000000000
   14010                                                          10987654321098765432109876543210
   14011                                                          xxxxxxxxxx00111xxxxxx1xx0111011x
   14012                                                          uabdl2.  */
   14013                                                       return 89;
   14014                                                     }
   14015                                                 }
   14016                                             }
   14017                                         }
   14018                                     }
   14019                                   else
   14020                                     {
   14021                                       if (((word >> 30) & 0x1) == 0)
   14022                                         {
   14023                                           /* 33222222222211111111110000000000
   14024                                              10987654321098765432109876543210
   14025                                              xxxxxxxxxx001xxxxxxxx1xx01111x0x
   14026                                              fmov.  */
   14027                                           return 848;
   14028                                         }
   14029                                       else
   14030                                         {
   14031                                           if (((word >> 13) & 0x1) == 0)
   14032                                             {
   14033                                               if (((word >> 14) & 0x1) == 0)
   14034                                                 {
   14035                                                   /* 33222222222211111111110000000000
   14036                                                      10987654321098765432109876543210
   14037                                                      xxxxxxxxxx00100xxxxxx1xx01111x1x
   14038                                                      sqdmlal.  */
   14039                                                   return 416;
   14040                                                 }
   14041                                               else
   14042                                                 {
   14043                                                   /* 33222222222211111111110000000000
   14044                                                      10987654321098765432109876543210
   14045                                                      xxxxxxxxxx00101xxxxxx1xx01111x1x
   14046                                                      sqdmull.  */
   14047                                                   return 418;
   14048                                                 }
   14049                                             }
   14050                                           else
   14051                                             {
   14052                                               /* 33222222222211111111110000000000
   14053                                                  10987654321098765432109876543210
   14054                                                  xxxxxxxxxx0011xxxxxxx1xx01111x1x
   14055                                                  sqdmlsl.  */
   14056                                               return 417;
   14057                                             }
   14058                                         }
   14059                                     }
   14060                                 }
   14061                             }
   14062                           else
   14063                             {
   14064                               if (((word >> 12) & 0x1) == 0)
   14065                                 {
   14066                                   if (((word >> 13) & 0x1) == 0)
   14067                                     {
   14068                                       if (((word >> 14) & 0x1) == 0)
   14069                                         {
   14070                                           if (((word >> 15) & 0x1) == 0)
   14071                                             {
   14072                                               if (((word >> 28) & 0x1) == 0)
   14073                                                 {
   14074                                                   if (((word >> 29) & 0x1) == 0)
   14075                                                     {
   14076                                                       /* 33222222222211111111110000000000
   14077                                                          10987654321098765432109876543210
   14078                                                          xxxxxxxxxx010000xxxxx1xx011100xx
   14079                                                          rev64.  */
   14080                                                       return 156;
   14081                                                     }
   14082                                                   else
   14083                                                     {
   14084                                                       /* 33222222222211111111110000000000
   14085                                                          10987654321098765432109876543210
   14086                                                          xxxxxxxxxx010000xxxxx1xx011101xx
   14087                                                          rev32.  */
   14088                                                       return 207;
   14089                                                     }
   14090                                                 }
   14091                                               else
   14092                                                 {
   14093                                                   if (((word >> 30) & 0x1) == 0)
   14094                                                     {
   14095                                                       /* 33222222222211111111110000000000
   14096                                                          10987654321098765432109876543210
   14097                                                          xxxxxxxxxx010000xxxxx1xx01111x0x
   14098                                                          fmul.  */
   14099                                                       return 822;
   14100                                                     }
   14101                                                   else
   14102                                                     {
   14103                                                       /* 33222222222211111111110000000000
   14104                                                          10987654321098765432109876543210
   14105                                                          xxxxxxxxxx010000xxxxx1xx01111x1x
   14106                                                          sha1h.  */
   14107                                                       return 669;
   14108                                                     }
   14109                                                 }
   14110                                             }
   14111                                           else
   14112                                             {
   14113                                               if (((word >> 28) & 0x1) == 0)
   14114                                                 {
   14115                                                   if (((word >> 16) & 0x1) == 0)
   14116                                                     {
   14117                                                       if (((word >> 29) & 0x1) == 0)
   14118                                                         {
   14119                                                           /* 33222222222211111111110000000000
   14120                                                              10987654321098765432109876543210
   14121                                                              xxxxxxxxxx0100010xxxx1xx011100xx
   14122                                                              cmgt.  */
   14123                                                           return 164;
   14124                                                         }
   14125                                                       else
   14126                                                         {
   14127                                                           /* 33222222222211111111110000000000
   14128                                                              10987654321098765432109876543210
   14129                                                              xxxxxxxxxx0100010xxxx1xx011101xx
   14130                                                              cmge.  */
   14131                                                           return 213;
   14132                                                         }
   14133                                                     }
   14134                                                   else
   14135                                                     {
   14136                                                       if (((word >> 19) & 0x1) == 0)
   14137                                                         {
   14138                                                           if (((word >> 23) & 0x1) == 0)
   14139                                                             {
   14140                                                               if (((word >> 29) & 0x1) == 0)
   14141                                                                 {
   14142                                                                   /* 33222222222211111111110000000000
   14143                                                                      10987654321098765432109876543210
   14144                                                                      xxxxxxxxxx0100011xx0x1x0011100xx
   14145                                                                      frintn.  */
   14146                                                                   return 176;
   14147                                                                 }
   14148                                                               else
   14149                                                                 {
   14150                                                                   /* 33222222222211111111110000000000
   14151                                                                      10987654321098765432109876543210
   14152                                                                      xxxxxxxxxx0100011xx0x1x0011101xx
   14153                                                                      frinta.  */
   14154                                                                   return 224;
   14155                                                                 }
   14156                                                             }
   14157                                                           else
   14158                                                             {
   14159                                                               /* 33222222222211111111110000000000
   14160                                                                  10987654321098765432109876543210
   14161                                                                  xxxxxxxxxx0100011xx0x1x101110xxx
   14162                                                                  frintp.  */
   14163                                                               return 196;
   14164                                                             }
   14165                                                         }
   14166                                                       else
   14167                                                         {
   14168                                                           if (((word >> 23) & 0x1) == 0)
   14169                                                             {
   14170                                                               if (((word >> 29) & 0x1) == 0)
   14171                                                                 {
   14172                                                                   /* 33222222222211111111110000000000
   14173                                                                      10987654321098765432109876543210
   14174                                                                      xxxxxxxxxx0100011xx1x1x0011100xx
   14175                                                                      frintn.  */
   14176                                                                   return 177;
   14177                                                                 }
   14178                                                               else
   14179                                                                 {
   14180                                                                   /* 33222222222211111111110000000000
   14181                                                                      10987654321098765432109876543210
   14182                                                                      xxxxxxxxxx0100011xx1x1x0011101xx
   14183                                                                      frinta.  */
   14184                                                                   return 225;
   14185                                                                 }
   14186                                                             }
   14187                                                           else
   14188                                                             {
   14189                                                               /* 33222222222211111111110000000000
   14190                                                                  10987654321098765432109876543210
   14191                                                                  xxxxxxxxxx0100011xx1x1x101110xxx
   14192                                                                  frintp.  */
   14193                                                               return 197;
   14194                                                             }
   14195                                                         }
   14196                                                     }
   14197                                                 }
   14198                                               else
   14199                                                 {
   14200                                                   if (((word >> 29) & 0x1) == 0)
   14201                                                     {
   14202                                                       if (((word >> 30) & 0x1) == 0)
   14203                                                         {
   14204                                                           /* 33222222222211111111110000000000
   14205                                                              10987654321098765432109876543210
   14206                                                              xxxxxxxxxx010001xxxxx1xx0111100x
   14207                                                              fnmul.  */
   14208                                                           return 838;
   14209                                                         }
   14210                                                       else
   14211                                                         {
   14212                                                           /* 33222222222211111111110000000000
   14213                                                              10987654321098765432109876543210
   14214                                                              xxxxxxxxxx010001xxxxx1xx0111101x
   14215                                                              cmgt.  */
   14216                                                           return 476;
   14217                                                         }
   14218                                                     }
   14219                                                   else
   14220                                                     {
   14221                                                       /* 33222222222211111111110000000000
   14222                                                          10987654321098765432109876543210
   14223                                                          xxxxxxxxxx010001xxxxx1xx011111xx
   14224                                                          cmge.  */
   14225                                                       return 505;
   14226                                                     }
   14227                                                 }
   14228                                             }
   14229                                         }
   14230                                       else
   14231                                         {
   14232                                           if (((word >> 15) & 0x1) == 0)
   14233                                             {
   14234                                               if (((word >> 28) & 0x1) == 0)
   14235                                                 {
   14236                                                   if (((word >> 16) & 0x1) == 0)
   14237                                                     {
   14238                                                       if (((word >> 19) & 0x1) == 0)
   14239                                                         {
   14240                                                           if (((word >> 29) & 0x1) == 0)
   14241                                                             {
   14242                                                               /* 33222222222211111111110000000000
   14243                                                                  10987654321098765432109876543210
   14244                                                                  xxxxxxxxxx0100100xx0x1xx011100xx
   14245                                                                  cls.  */
   14246                                                               return 160;
   14247                                                             }
   14248                                                           else
   14249                                                             {
   14250                                                               /* 33222222222211111111110000000000
   14251                                                                  10987654321098765432109876543210
   14252                                                                  xxxxxxxxxx0100100xx0x1xx011101xx
   14253                                                                  clz.  */
   14254                                                               return 210;
   14255                                                             }
   14256                                                         }
   14257                                                       else
   14258                                                         {
   14259                                                           /* 33222222222211111111110000000000
   14260                                                              10987654321098765432109876543210
   14261                                                              xxxxxxxxxx0100100xx1x1xx01110xxx
   14262                                                              aese.  */
   14263                                                           return 665;
   14264                                                         }
   14265                                                     }
   14266                                                   else
   14267                                                     {
   14268                                                       if (((word >> 29) & 0x1) == 0)
   14269                                                         {
   14270                                                           if (((word >> 30) & 0x1) == 0)
   14271                                                             {
   14272                                                               /* 33222222222211111111110000000000
   14273                                                                  10987654321098765432109876543210
   14274                                                                  xxxxxxxxxx0100101xxxx1xx0111000x
   14275                                                                  sqxtn.  */
   14276                                                               return 170;
   14277                                                             }
   14278                                                           else
   14279                                                             {
   14280                                                               /* 33222222222211111111110000000000
   14281                                                                  10987654321098765432109876543210
   14282                                                                  xxxxxxxxxx0100101xxxx1xx0111001x
   14283                                                                  sqxtn2.  */
   14284                                                               return 171;
   14285                                                             }
   14286                                                         }
   14287                                                       else
   14288                                                         {
   14289                                                           if (((word >> 30) & 0x1) == 0)
   14290                                                             {
   14291                                                               /* 33222222222211111111110000000000
   14292                                                                  10987654321098765432109876543210
   14293                                                                  xxxxxxxxxx0100101xxxx1xx0111010x
   14294                                                                  uqxtn.  */
   14295                                                               return 220;
   14296                                                             }
   14297                                                           else
   14298                                                             {
   14299                                                               /* 33222222222211111111110000000000
   14300                                                                  10987654321098765432109876543210
   14301                                                                  xxxxxxxxxx0100101xxxx1xx0111011x
   14302                                                                  uqxtn2.  */
   14303                                                               return 221;
   14304                                                             }
   14305                                                         }
   14306                                                     }
   14307                                                 }
   14308                                               else
   14309                                                 {
   14310                                                   if (((word >> 29) & 0x1) == 0)
   14311                                                     {
   14312                                                       if (((word >> 30) & 0x1) == 0)
   14313                                                         {
   14314                                                           /* 33222222222211111111110000000000
   14315                                                              10987654321098765432109876543210
   14316                                                              xxxxxxxxxx010010xxxxx1xx0111100x
   14317                                                              fmax.  */
   14318                                                           return 830;
   14319                                                         }
   14320                                                       else
   14321                                                         {
   14322                                                           /* 33222222222211111111110000000000
   14323                                                              10987654321098765432109876543210
   14324                                                              xxxxxxxxxx010010xxxxx1xx0111101x
   14325                                                              sqxtn.  */
   14326                                                           return 480;
   14327                                                         }
   14328                                                     }
   14329                                                   else
   14330                                                     {
   14331                                                       /* 33222222222211111111110000000000
   14332                                                          10987654321098765432109876543210
   14333                                                          xxxxxxxxxx010010xxxxx1xx011111xx
   14334                                                          uqxtn.  */
   14335                                                       return 509;
   14336                                                     }
   14337                                                 }
   14338                                             }
   14339                                           else
   14340                                             {
   14341                                               if (((word >> 16) & 0x1) == 0)
   14342                                                 {
   14343                                                   if (((word >> 19) & 0x1) == 0)
   14344                                                     {
   14345                                                       if (((word >> 20) & 0x1) == 0)
   14346                                                         {
   14347                                                           if (((word >> 28) & 0x1) == 0)
   14348                                                             {
   14349                                                               if (((word >> 29) & 0x1) == 0)
   14350                                                                 {
   14351                                                                   /* 33222222222211111111110000000000
   14352                                                                      10987654321098765432109876543210
   14353                                                                      xxxxxxxxxx0100110xx001xx011100xx
   14354                                                                      fcmgt.  */
   14355                                                                   return 188;
   14356                                                                 }
   14357                                                               else
   14358                                                                 {
   14359                                                                   /* 33222222222211111111110000000000
   14360                                                                      10987654321098765432109876543210
   14361                                                                      xxxxxxxxxx0100110xx001xx011101xx
   14362                                                                      fcmge.  */
   14363                                                                   return 239;
   14364                                                                 }
   14365                                                             }
   14366                                                           else
   14367                                                             {
   14368                                                               if (((word >> 29) & 0x1) == 0)
   14369                                                                 {
   14370                                                                   /* 33222222222211111111110000000000
   14371                                                                      10987654321098765432109876543210
   14372                                                                      xxxxxxxxxx0100110xx001xx011110xx
   14373                                                                      fcmgt.  */
   14374                                                                   return 489;
   14375                                                                 }
   14376                                                               else
   14377                                                                 {
   14378                                                                   /* 33222222222211111111110000000000
   14379                                                                      10987654321098765432109876543210
   14380                                                                      xxxxxxxxxx0100110xx001xx011111xx
   14381                                                                      fcmge.  */
   14382                                                                   return 519;
   14383                                                                 }
   14384                                                             }
   14385                                                         }
   14386                                                       else
   14387                                                         {
   14388                                                           if (((word >> 23) & 0x1) == 0)
   14389                                                             {
   14390                                                               if (((word >> 28) & 0x1) == 0)
   14391                                                                 {
   14392                                                                   if (((word >> 29) & 0x1) == 0)
   14393                                                                     {
   14394                                                                       /* 33222222222211111111110000000000
   14395                                                                          10987654321098765432109876543210
   14396                                                                          xxxxxxxxxx0100110xx011x0011100xx
   14397                                                                          fmaxnmv.  */
   14398                                                                       return 35;
   14399                                                                     }
   14400                                                                   else
   14401                                                                     {
   14402                                                                       /* 33222222222211111111110000000000
   14403                                                                          10987654321098765432109876543210
   14404                                                                          xxxxxxxxxx0100110xx011x0011101xx
   14405                                                                          fmaxnmv.  */
   14406                                                                       return 34;
   14407                                                                     }
   14408                                                                 }
   14409                                                               else
   14410                                                                 {
   14411                                                                   if (((word >> 29) & 0x1) == 0)
   14412                                                                     {
   14413                                                                       /* 33222222222211111111110000000000
   14414                                                                          10987654321098765432109876543210
   14415                                                                          xxxxxxxxxx0100110xx011x0011110xx
   14416                                                                          fmaxnmp.  */
   14417                                                                       return 533;
   14418                                                                     }
   14419                                                                   else
   14420                                                                     {
   14421                                                                       /* 33222222222211111111110000000000
   14422                                                                          10987654321098765432109876543210
   14423                                                                          xxxxxxxxxx0100110xx011x0011111xx
   14424                                                                          fmaxnmp.  */
   14425                                                                       return 532;
   14426                                                                     }
   14427                                                                 }
   14428                                                             }
   14429                                                           else
   14430                                                             {
   14431                                                               if (((word >> 28) & 0x1) == 0)
   14432                                                                 {
   14433                                                                   if (((word >> 29) & 0x1) == 0)
   14434                                                                     {
   14435                                                                       /* 33222222222211111111110000000000
   14436                                                                          10987654321098765432109876543210
   14437                                                                          xxxxxxxxxx0100110xx011x1011100xx
   14438                                                                          fminnmv.  */
   14439                                                                       return 39;
   14440                                                                     }
   14441                                                                   else
   14442                                                                     {
   14443                                                                       /* 33222222222211111111110000000000
   14444                                                                          10987654321098765432109876543210
   14445                                                                          xxxxxxxxxx0100110xx011x1011101xx
   14446                                                                          fminnmv.  */
   14447                                                                       return 38;
   14448                                                                     }
   14449                                                                 }
   14450                                                               else
   14451                                                                 {
   14452                                                                   if (((word >> 29) & 0x1) == 0)
   14453                                                                     {
   14454                                                                       /* 33222222222211111111110000000000
   14455                                                                          10987654321098765432109876543210
   14456                                                                          xxxxxxxxxx0100110xx011x1011110xx
   14457                                                                          fminnmp.  */
   14458                                                                       return 539;
   14459                                                                     }
   14460                                                                   else
   14461                                                                     {
   14462                                                                       /* 33222222222211111111110000000000
   14463                                                                          10987654321098765432109876543210
   14464                                                                          xxxxxxxxxx0100110xx011x1011111xx
   14465                                                                          fminnmp.  */
   14466                                                                       return 538;
   14467                                                                     }
   14468                                                                 }
   14469                                                             }
   14470                                                         }
   14471                                                     }
   14472                                                   else
   14473                                                     {
   14474                                                       if (((word >> 28) & 0x1) == 0)
   14475                                                         {
   14476                                                           if (((word >> 29) & 0x1) == 0)
   14477                                                             {
   14478                                                               /* 33222222222211111111110000000000
   14479                                                                  10987654321098765432109876543210
   14480                                                                  xxxxxxxxxx0100110xx1x1xx011100xx
   14481                                                                  fcmgt.  */
   14482                                                               return 189;
   14483                                                             }
   14484                                                           else
   14485                                                             {
   14486                                                               /* 33222222222211111111110000000000
   14487                                                                  10987654321098765432109876543210
   14488                                                                  xxxxxxxxxx0100110xx1x1xx011101xx
   14489                                                                  fcmge.  */
   14490                                                               return 240;
   14491                                                             }
   14492                                                         }
   14493                                                       else
   14494                                                         {
   14495                                                           if (((word >> 29) & 0x1) == 0)
   14496                                                             {
   14497                                                               /* 33222222222211111111110000000000
   14498                                                                  10987654321098765432109876543210
   14499                                                                  xxxxxxxxxx0100110xx1x1xx011110xx
   14500                                                                  fcmgt.  */
   14501                                                               return 490;
   14502                                                             }
   14503                                                           else
   14504                                                             {
   14505                                                               /* 33222222222211111111110000000000
   14506                                                                  10987654321098765432109876543210
   14507                                                                  xxxxxxxxxx0100110xx1x1xx011111xx
   14508                                                                  fcmge.  */
   14509                                                               return 520;
   14510                                                             }
   14511                                                         }
   14512                                                     }
   14513                                                 }
   14514                                               else
   14515                                                 {
   14516                                                   if (((word >> 19) & 0x1) == 0)
   14517                                                     {
   14518                                                       if (((word >> 23) & 0x1) == 0)
   14519                                                         {
   14520                                                           if (((word >> 28) & 0x1) == 0)
   14521                                                             {
   14522                                                               if (((word >> 29) & 0x1) == 0)
   14523                                                                 {
   14524                                                                   /* 33222222222211111111110000000000
   14525                                                                      10987654321098765432109876543210
   14526                                                                      xxxxxxxxxx0100111xx0x1x0011100xx
   14527                                                                      fcvtas.  */
   14528                                                                   return 184;
   14529                                                                 }
   14530                                                               else
   14531                                                                 {
   14532                                                                   /* 33222222222211111111110000000000
   14533                                                                      10987654321098765432109876543210
   14534                                                                      xxxxxxxxxx0100111xx0x1x0011101xx
   14535                                                                      fcvtau.  */
   14536                                                                   return 232;
   14537                                                                 }
   14538                                                             }
   14539                                                           else
   14540                                                             {
   14541                                                               if (((word >> 29) & 0x1) == 0)
   14542                                                                 {
   14543                                                                   /* 33222222222211111111110000000000
   14544                                                                      10987654321098765432109876543210
   14545                                                                      xxxxxxxxxx0100111xx0x1x0011110xx
   14546                                                                      fcvtas.  */
   14547                                                                   return 485;
   14548                                                                 }
   14549                                                               else
   14550                                                                 {
   14551                                                                   /* 33222222222211111111110000000000
   14552                                                                      10987654321098765432109876543210
   14553                                                                      xxxxxxxxxx0100111xx0x1x0011111xx
   14554                                                                      fcvtau.  */
   14555                                                                   return 515;
   14556                                                                 }
   14557                                                             }
   14558                                                         }
   14559                                                       else
   14560                                                         {
   14561                                                           if (((word >> 29) & 0x1) == 0)
   14562                                                             {
   14563                                                               /* 33222222222211111111110000000000
   14564                                                                  10987654321098765432109876543210
   14565                                                                  xxxxxxxxxx0100111xx0x1x10111x0xx
   14566                                                                  urecpe.  */
   14567                                                               return 204;
   14568                                                             }
   14569                                                           else
   14570                                                             {
   14571                                                               /* 33222222222211111111110000000000
   14572                                                                  10987654321098765432109876543210
   14573                                                                  xxxxxxxxxx0100111xx0x1x10111x1xx
   14574                                                                  ursqrte.  */
   14575                                                               return 251;
   14576                                                             }
   14577                                                         }
   14578                                                     }
   14579                                                   else
   14580                                                     {
   14581                                                       if (((word >> 28) & 0x1) == 0)
   14582                                                         {
   14583                                                           if (((word >> 29) & 0x1) == 0)
   14584                                                             {
   14585                                                               /* 33222222222211111111110000000000
   14586                                                                  10987654321098765432109876543210
   14587                                                                  xxxxxxxxxx0100111xx1x1xx011100xx
   14588                                                                  fcvtas.  */
   14589                                                               return 185;
   14590                                                             }
   14591                                                           else
   14592                                                             {
   14593                                                               /* 33222222222211111111110000000000
   14594                                                                  10987654321098765432109876543210
   14595                                                                  xxxxxxxxxx0100111xx1x1xx011101xx
   14596                                                                  fcvtau.  */
   14597                                                               return 233;
   14598                                                             }
   14599                                                         }
   14600                                                       else
   14601                                                         {
   14602                                                           if (((word >> 29) & 0x1) == 0)
   14603                                                             {
   14604                                                               /* 33222222222211111111110000000000
   14605                                                                  10987654321098765432109876543210
   14606                                                                  xxxxxxxxxx0100111xx1x1xx011110xx
   14607                                                                  fcvtas.  */
   14608                                                               return 486;
   14609                                                             }
   14610                                                           else
   14611                                                             {
   14612                                                               /* 33222222222211111111110000000000
   14613                                                                  10987654321098765432109876543210
   14614                                                                  xxxxxxxxxx0100111xx1x1xx011111xx
   14615                                                                  fcvtau.  */
   14616                                                               return 516;
   14617                                                             }
   14618                                                         }
   14619                                                     }
   14620                                                 }
   14621                                             }
   14622                                         }
   14623                                     }
   14624                                   else
   14625                                     {
   14626                                       if (((word >> 14) & 0x1) == 0)
   14627                                         {
   14628                                           if (((word >> 15) & 0x1) == 0)
   14629                                             {
   14630                                               if (((word >> 28) & 0x1) == 0)
   14631                                                 {
   14632                                                   if (((word >> 16) & 0x1) == 0)
   14633                                                     {
   14634                                                       if (((word >> 29) & 0x1) == 0)
   14635                                                         {
   14636                                                           /* 33222222222211111111110000000000
   14637                                                              10987654321098765432109876543210
   14638                                                              xxxxxxxxxx0101000xxxx1xx011100xx
   14639                                                              saddlp.  */
   14640                                                           return 158;
   14641                                                         }
   14642                                                       else
   14643                                                         {
   14644                                                           /* 33222222222211111111110000000000
   14645                                                              10987654321098765432109876543210
   14646                                                              xxxxxxxxxx0101000xxxx1xx011101xx
   14647                                                              uaddlp.  */
   14648                                                           return 208;
   14649                                                         }
   14650                                                     }
   14651                                                   else
   14652                                                     {
   14653                                                       if (((word >> 29) & 0x1) == 0)
   14654                                                         {
   14655                                                           if (((word >> 30) & 0x1) == 0)
   14656                                                             {
   14657                                                               /* 33222222222211111111110000000000
   14658                                                                  10987654321098765432109876543210
   14659                                                                  xxxxxxxxxx0101001xxxx1xx0111000x
   14660                                                                  xtn.  */
   14661                                                               return 168;
   14662                                                             }
   14663                                                           else
   14664                                                             {
   14665                                                               /* 33222222222211111111110000000000
   14666                                                                  10987654321098765432109876543210
   14667                                                                  xxxxxxxxxx0101001xxxx1xx0111001x
   14668                                                                  xtn2.  */
   14669                                                               return 169;
   14670                                                             }
   14671                                                         }
   14672                                                       else
   14673                                                         {
   14674                                                           if (((word >> 30) & 0x1) == 0)
   14675                                                             {
   14676                                                               /* 33222222222211111111110000000000
   14677                                                                  10987654321098765432109876543210
   14678                                                                  xxxxxxxxxx0101001xxxx1xx0111010x
   14679                                                                  sqxtun.  */
   14680                                                               return 216;
   14681                                                             }
   14682                                                           else
   14683                                                             {
   14684                                                               /* 33222222222211111111110000000000
   14685                                                                  10987654321098765432109876543210
   14686                                                                  xxxxxxxxxx0101001xxxx1xx0111011x
   14687                                                                  sqxtun2.  */
   14688                                                               return 217;
   14689                                                             }
   14690                                                         }
   14691                                                     }
   14692                                                 }
   14693                                               else
   14694                                                 {
   14695                                                   if (((word >> 29) & 0x1) == 0)
   14696                                                     {
   14697                                                       if (((word >> 30) & 0x1) == 0)
   14698                                                         {
   14699                                                           /* 33222222222211111111110000000000
   14700                                                              10987654321098765432109876543210
   14701                                                              xxxxxxxxxx010100xxxxx1xx0111100x
   14702                                                              fadd.  */
   14703                                                           return 826;
   14704                                                         }
   14705                                                       else
   14706                                                         {
   14707                                                           /* 33222222222211111111110000000000
   14708                                                              10987654321098765432109876543210
   14709                                                              xxxxxxxxxx010100xxxxx1xx0111101x
   14710                                                              sha256su0.  */
   14711                                                           return 671;
   14712                                                         }
   14713                                                     }
   14714                                                   else
   14715                                                     {
   14716                                                       /* 33222222222211111111110000000000
   14717                                                          10987654321098765432109876543210
   14718                                                          xxxxxxxxxx010100xxxxx1xx011111xx
   14719                                                          sqxtun.  */
   14720                                                       return 508;
   14721                                                     }
   14722                                                 }
   14723                                             }
   14724                                           else
   14725                                             {
   14726                                               if (((word >> 16) & 0x1) == 0)
   14727                                                 {
   14728                                                   if (((word >> 20) & 0x1) == 0)
   14729                                                     {
   14730                                                       if (((word >> 28) & 0x1) == 0)
   14731                                                         {
   14732                                                           /* 33222222222211111111110000000000
   14733                                                              10987654321098765432109876543210
   14734                                                              xxxxxxxxxx0101010xxx01xx01110xxx
   14735                                                              cmlt.  */
   14736                                                           return 166;
   14737                                                         }
   14738                                                       else
   14739                                                         {
   14740                                                           /* 33222222222211111111110000000000
   14741                                                              10987654321098765432109876543210
   14742                                                              xxxxxxxxxx0101010xxx01xx01111xxx
   14743                                                              cmlt.  */
   14744                                                           return 478;
   14745                                                         }
   14746                                                     }
   14747                                                   else
   14748                                                     {
   14749                                                       if (((word >> 29) & 0x1) == 0)
   14750                                                         {
   14751                                                           /* 33222222222211111111110000000000
   14752                                                              10987654321098765432109876543210
   14753                                                              xxxxxxxxxx0101010xxx11xx0111x0xx
   14754                                                              smaxv.  */
   14755                                                           return 28;
   14756                                                         }
   14757                                                       else
   14758                                                         {
   14759                                                           /* 33222222222211111111110000000000
   14760                                                              10987654321098765432109876543210
   14761                                                              xxxxxxxxxx0101010xxx11xx0111x1xx
   14762                                                              umaxv.  */
   14763                                                           return 32;
   14764                                                         }
   14765                                                     }
   14766                                                 }
   14767                                               else
   14768                                                 {
   14769                                                   if (((word >> 19) & 0x1) == 0)
   14770                                                     {
   14771                                                       if (((word >> 20) & 0x1) == 0)
   14772                                                         {
   14773                                                           if (((word >> 23) & 0x1) == 0)
   14774                                                             {
   14775                                                               if (((word >> 28) & 0x1) == 0)
   14776                                                                 {
   14777                                                                   if (((word >> 29) & 0x1) == 0)
   14778                                                                     {
   14779                                                                       /* 33222222222211111111110000000000
   14780                                                                          10987654321098765432109876543210
   14781                                                                          xxxxxxxxxx0101011xx001x0011100xx
   14782                                                                          fcvtns.  */
   14783                                                                       return 180;
   14784                                                                     }
   14785                                                                   else
   14786                                                                     {
   14787                                                                       /* 33222222222211111111110000000000
   14788                                                                          10987654321098765432109876543210
   14789                                                                          xxxxxxxxxx0101011xx001x0011101xx
   14790                                                                          fcvtnu.  */
   14791                                                                       return 228;
   14792                                                                     }
   14793                                                                 }
   14794                                                               else
   14795                                                                 {
   14796                                                                   if (((word >> 29) & 0x1) == 0)
   14797                                                                     {
   14798                                                                       /* 33222222222211111111110000000000
   14799                                                                          10987654321098765432109876543210
   14800                                                                          xxxxxxxxxx0101011xx001x0011110xx
   14801                                                                          fcvtns.  */
   14802                                                                       return 481;
   14803                                                                     }
   14804                                                                   else
   14805                                                                     {
   14806                                                                       /* 33222222222211111111110000000000
   14807                                                                          10987654321098765432109876543210
   14808                                                                          xxxxxxxxxx0101011xx001x0011111xx
   14809                                                                          fcvtnu.  */
   14810                                                                       return 511;
   14811                                                                     }
   14812                                                                 }
   14813                                                             }
   14814                                                           else
   14815                                                             {
   14816                                                               if (((word >> 28) & 0x1) == 0)
   14817                                                                 {
   14818                                                                   if (((word >> 29) & 0x1) == 0)
   14819                                                                     {
   14820                                                                       /* 33222222222211111111110000000000
   14821                                                                          10987654321098765432109876543210
   14822                                                                          xxxxxxxxxx0101011xx001x1011100xx
   14823                                                                          fcvtps.  */
   14824                                                                       return 200;
   14825                                                                     }
   14826                                                                   else
   14827                                                                     {
   14828                                                                       /* 33222222222211111111110000000000
   14829                                                                          10987654321098765432109876543210
   14830                                                                          xxxxxxxxxx0101011xx001x1011101xx
   14831                                                                          fcvtpu.  */
   14832                                                                       return 247;
   14833                                                                     }
   14834                                                                 }
   14835                                                               else
   14836                                                                 {
   14837                                                                   if (((word >> 29) & 0x1) == 0)
   14838                                                                     {
   14839                                                                       /* 33222222222211111111110000000000
   14840                                                                          10987654321098765432109876543210
   14841                                                                          xxxxxxxxxx0101011xx001x1011110xx
   14842                                                                          fcvtps.  */
   14843                                                                       return 495;
   14844                                                                     }
   14845                                                                   else
   14846                                                                     {
   14847                                                                       /* 33222222222211111111110000000000
   14848                                                                          10987654321098765432109876543210
   14849                                                                          xxxxxxxxxx0101011xx001x1011111xx
   14850                                                                          fcvtpu.  */
   14851                                                                       return 523;
   14852                                                                     }
   14853                                                                 }
   14854                                                             }
   14855                                                         }
   14856                                                       else
   14857                                                         {
   14858                                                           if (((word >> 29) & 0x1) == 0)
   14859                                                             {
   14860                                                               /* 33222222222211111111110000000000
   14861                                                                  10987654321098765432109876543210
   14862                                                                  xxxxxxxxxx0101011xx011xx0111x0xx
   14863                                                                  sminv.  */
   14864                                                               return 29;
   14865                                                             }
   14866                                                           else
   14867                                                             {
   14868                                                               /* 33222222222211111111110000000000
   14869                                                                  10987654321098765432109876543210
   14870                                                                  xxxxxxxxxx0101011xx011xx0111x1xx
   14871                                                                  uminv.  */
   14872                                                               return 33;
   14873                                                             }
   14874                                                         }
   14875                                                     }
   14876                                                   else
   14877                                                     {
   14878                                                       if (((word >> 23) & 0x1) == 0)
   14879                                                         {
   14880                                                           if (((word >> 28) & 0x1) == 0)
   14881                                                             {
   14882                                                               if (((word >> 29) & 0x1) == 0)
   14883                                                                 {
   14884                                                                   /* 33222222222211111111110000000000
   14885                                                                      10987654321098765432109876543210
   14886                                                                      xxxxxxxxxx0101011xx1x1x0011100xx
   14887                                                                      fcvtns.  */
   14888                                                                   return 181;
   14889                                                                 }
   14890                                                               else
   14891                                                                 {
   14892                                                                   /* 33222222222211111111110000000000
   14893                                                                      10987654321098765432109876543210
   14894                                                                      xxxxxxxxxx0101011xx1x1x0011101xx
   14895                                                                      fcvtnu.  */
   14896                                                                   return 229;
   14897                                                                 }
   14898                                                             }
   14899                                                           else
   14900                                                             {
   14901                                                               if (((word >> 29) & 0x1) == 0)
   14902                                                                 {
   14903                                                                   /* 33222222222211111111110000000000
   14904                                                                      10987654321098765432109876543210
   14905                                                                      xxxxxxxxxx0101011xx1x1x0011110xx
   14906                                                                      fcvtns.  */
   14907                                                                   return 482;
   14908                                                                 }
   14909                                                               else
   14910                                                                 {
   14911                                                                   /* 33222222222211111111110000000000
   14912                                                                      10987654321098765432109876543210
   14913                                                                      xxxxxxxxxx0101011xx1x1x0011111xx
   14914                                                                      fcvtnu.  */
   14915                                                                   return 512;
   14916                                                                 }
   14917                                                             }
   14918                                                         }
   14919                                                       else
   14920                                                         {
   14921                                                           if (((word >> 28) & 0x1) == 0)
   14922                                                             {
   14923                                                               if (((word >> 29) & 0x1) == 0)
   14924                                                                 {
   14925                                                                   /* 33222222222211111111110000000000
   14926                                                                      10987654321098765432109876543210
   14927                                                                      xxxxxxxxxx0101011xx1x1x1011100xx
   14928                                                                      fcvtps.  */
   14929                                                                   return 201;
   14930                                                                 }
   14931                                                               else
   14932                                                                 {
   14933                                                                   /* 33222222222211111111110000000000
   14934                                                                      10987654321098765432109876543210
   14935                                                                      xxxxxxxxxx0101011xx1x1x1011101xx
   14936                                                                      fcvtpu.  */
   14937                                                                   return 248;
   14938                                                                 }
   14939                                                             }
   14940                                                           else
   14941                                                             {
   14942                                                               if (((word >> 29) & 0x1) == 0)
   14943                                                                 {
   14944                                                                   /* 33222222222211111111110000000000
   14945                                                                      10987654321098765432109876543210
   14946                                                                      xxxxxxxxxx0101011xx1x1x1011110xx
   14947                                                                      fcvtps.  */
   14948                                                                   return 496;
   14949                                                                 }
   14950                                                               else
   14951                                                                 {
   14952                                                                   /* 33222222222211111111110000000000
   14953                                                                      10987654321098765432109876543210
   14954                                                                      xxxxxxxxxx0101011xx1x1x1011111xx
   14955                                                                      fcvtpu.  */
   14956                                                                   return 524;
   14957                                                                 }
   14958                                                             }
   14959                                                         }
   14960                                                     }
   14961                                                 }
   14962                                             }
   14963                                         }
   14964                                       else
   14965                                         {
   14966                                           if (((word >> 15) & 0x1) == 0)
   14967                                             {
   14968                                               if (((word >> 28) & 0x1) == 0)
   14969                                                 {
   14970                                                   if (((word >> 16) & 0x1) == 0)
   14971                                                     {
   14972                                                       if (((word >> 19) & 0x1) == 0)
   14973                                                         {
   14974                                                           if (((word >> 29) & 0x1) == 0)
   14975                                                             {
   14976                                                               /* 33222222222211111111110000000000
   14977                                                                  10987654321098765432109876543210
   14978                                                                  xxxxxxxxxx0101100xx0x1xx011100xx
   14979                                                                  sadalp.  */
   14980                                                               return 162;
   14981                                                             }
   14982                                                           else
   14983                                                             {
   14984                                                               /* 33222222222211111111110000000000
   14985                                                                  10987654321098765432109876543210
   14986                                                                  xxxxxxxxxx0101100xx0x1xx011101xx
   14987                                                                  uadalp.  */
   14988                                                               return 211;
   14989                                                             }
   14990                                                         }
   14991                                                       else
   14992                                                         {
   14993                                                           /* 33222222222211111111110000000000
   14994                                                              10987654321098765432109876543210
   14995                                                              xxxxxxxxxx0101100xx1x1xx01110xxx
   14996                                                              aesmc.  */
   14997                                                           return 667;
   14998                                                         }
   14999                                                     }
   15000                                                   else
   15001                                                     {
   15002                                                       if (((word >> 29) & 0x1) == 0)
   15003                                                         {
   15004                                                           if (((word >> 30) & 0x1) == 0)
   15005                                                             {
   15006                                                               /* 33222222222211111111110000000000
   15007                                                                  10987654321098765432109876543210
   15008                                                                  xxxxxxxxxx0101101xxxx1xx0111000x
   15009                                                                  fcvtn.  */
   15010                                                               return 172;
   15011                                                             }
   15012                                                           else
   15013                                                             {
   15014                                                               /* 33222222222211111111110000000000
   15015                                                                  10987654321098765432109876543210
   15016                                                                  xxxxxxxxxx0101101xxxx1xx0111001x
   15017                                                                  fcvtn2.  */
   15018                                                               return 173;
   15019                                                             }
   15020                                                         }
   15021                                                       else
   15022                                                         {
   15023                                                           if (((word >> 30) & 0x1) == 0)
   15024                                                             {
   15025                                                               /* 33222222222211111111110000000000
   15026                                                                  10987654321098765432109876543210
   15027                                                                  xxxxxxxxxx0101101xxxx1xx0111010x
   15028                                                                  fcvtxn.  */
   15029                                                               return 222;
   15030                                                             }
   15031                                                           else
   15032                                                             {
   15033                                                               /* 33222222222211111111110000000000
   15034                                                                  10987654321098765432109876543210
   15035                                                                  xxxxxxxxxx0101101xxxx1xx0111011x
   15036                                                                  fcvtxn2.  */
   15037                                                               return 223;
   15038                                                             }
   15039                                                         }
   15040                                                     }
   15041                                                 }
   15042                                               else
   15043                                                 {
   15044                                                   if (((word >> 29) & 0x1) == 0)
   15045                                                     {
   15046                                                       /* 33222222222211111111110000000000
   15047                                                          10987654321098765432109876543210
   15048                                                          xxxxxxxxxx010110xxxxx1xx011110xx
   15049                                                          fmaxnm.  */
   15050                                                       return 834;
   15051                                                     }
   15052                                                   else
   15053                                                     {
   15054                                                       /* 33222222222211111111110000000000
   15055                                                          10987654321098765432109876543210
   15056                                                          xxxxxxxxxx010110xxxxx1xx011111xx
   15057                                                          fcvtxn.  */
   15058                                                       return 510;
   15059                                                     }
   15060                                                 }
   15061                                             }
   15062                                           else
   15063                                             {
   15064                                               if (((word >> 19) & 0x1) == 0)
   15065                                                 {
   15066                                                   if (((word >> 28) & 0x1) == 0)
   15067                                                     {
   15068                                                       /* 33222222222211111111110000000000
   15069                                                          10987654321098765432109876543210
   15070                                                          xxxxxxxxxx010111xxx0x1xx01110xxx
   15071                                                          fcmlt.  */
   15072                                                       return 192;
   15073                                                     }
   15074                                                   else
   15075                                                     {
   15076                                                       /* 33222222222211111111110000000000
   15077                                                          10987654321098765432109876543210
   15078                                                          xxxxxxxxxx010111xxx0x1xx01111xxx
   15079                                                          fcmlt.  */
   15080                                                       return 493;
   15081                                                     }
   15082                                                 }
   15083                                               else
   15084                                                 {
   15085                                                   if (((word >> 28) & 0x1) == 0)
   15086                                                     {
   15087                                                       /* 33222222222211111111110000000000
   15088                                                          10987654321098765432109876543210
   15089                                                          xxxxxxxxxx010111xxx1x1xx01110xxx
   15090                                                          fcmlt.  */
   15091                                                       return 193;
   15092                                                     }
   15093                                                   else
   15094                                                     {
   15095                                                       /* 33222222222211111111110000000000
   15096                                                          10987654321098765432109876543210
   15097                                                          xxxxxxxxxx010111xxx1x1xx01111xxx
   15098                                                          fcmlt.  */
   15099                                                       return 494;
   15100                                                     }
   15101                                                 }
   15102                                             }
   15103                                         }
   15104                                     }
   15105                                 }
   15106                               else
   15107                                 {
   15108                                   if (((word >> 13) & 0x1) == 0)
   15109                                     {
   15110                                       if (((word >> 14) & 0x1) == 0)
   15111                                         {
   15112                                           if (((word >> 15) & 0x1) == 0)
   15113                                             {
   15114                                               if (((word >> 28) & 0x1) == 0)
   15115                                                 {
   15116                                                   /* 33222222222211111111110000000000
   15117                                                      10987654321098765432109876543210
   15118                                                      xxxxxxxxxx011000xxxxx1xx01110xxx
   15119                                                      rev16.  */
   15120                                                   return 157;
   15121                                                 }
   15122                                               else
   15123                                                 {
   15124                                                   if (((word >> 30) & 0x1) == 0)
   15125                                                     {
   15126                                                       /* 33222222222211111111110000000000
   15127                                                          10987654321098765432109876543210
   15128                                                          xxxxxxxxxx011000xxxxx1xx01111x0x
   15129                                                          fdiv.  */
   15130                                                       return 824;
   15131                                                     }
   15132                                                   else
   15133                                                     {
   15134                                                       /* 33222222222211111111110000000000
   15135                                                          10987654321098765432109876543210
   15136                                                          xxxxxxxxxx011000xxxxx1xx01111x1x
   15137                                                          sha1su1.  */
   15138                                                       return 670;
   15139                                                     }
   15140                                                 }
   15141                                             }
   15142                                           else
   15143                                             {
   15144                                               if (((word >> 16) & 0x1) == 0)
   15145                                                 {
   15146                                                   if (((word >> 28) & 0x1) == 0)
   15147                                                     {
   15148                                                       if (((word >> 29) & 0x1) == 0)
   15149                                                         {
   15150                                                           /* 33222222222211111111110000000000
   15151                                                              10987654321098765432109876543210
   15152                                                              xxxxxxxxxx0110010xxxx1xx011100xx
   15153                                                              cmeq.  */
   15154                                                           return 165;
   15155                                                         }
   15156                                                       else
   15157                                                         {
   15158                                                           /* 33222222222211111111110000000000
   15159                                                              10987654321098765432109876543210
   15160                                                              xxxxxxxxxx0110010xxxx1xx011101xx
   15161                                                              cmle.  */
   15162                                                           return 214;
   15163                                                         }
   15164                                                     }
   15165                                                   else
   15166                                                     {
   15167                                                       if (((word >> 29) & 0x1) == 0)
   15168                                                         {
   15169                                                           /* 33222222222211111111110000000000
   15170                                                              10987654321098765432109876543210
   15171                                                              xxxxxxxxxx0110010xxxx1xx011110xx
   15172                                                              cmeq.  */
   15173                                                           return 477;
   15174                                                         }
   15175                                                       else
   15176                                                         {
   15177                                                           /* 33222222222211111111110000000000
   15178                                                              10987654321098765432109876543210
   15179                                                              xxxxxxxxxx0110010xxxx1xx011111xx
   15180                                                              cmle.  */
   15181                                                           return 506;
   15182                                                         }
   15183                                                     }
   15184                                                 }
   15185                                               else
   15186                                                 {
   15187                                                   if (((word >> 19) & 0x1) == 0)
   15188                                                     {
   15189                                                       if (((word >> 23) & 0x1) == 0)
   15190                                                         {
   15191                                                           if (((word >> 29) & 0x1) == 0)
   15192                                                             {
   15193                                                               /* 33222222222211111111110000000000
   15194                                                                  10987654321098765432109876543210
   15195                                                                  xxxxxxxxxx0110011xx0x1x00111x0xx
   15196                                                                  frintm.  */
   15197                                                               return 178;
   15198                                                             }
   15199                                                           else
   15200                                                             {
   15201                                                               /* 33222222222211111111110000000000
   15202                                                                  10987654321098765432109876543210
   15203                                                                  xxxxxxxxxx0110011xx0x1x00111x1xx
   15204                                                                  frintx.  */
   15205                                                               return 226;
   15206                                                             }
   15207                                                         }
   15208                                                       else
   15209                                                         {
   15210                                                           if (((word >> 29) & 0x1) == 0)
   15211                                                             {
   15212                                                               /* 33222222222211111111110000000000
   15213                                                                  10987654321098765432109876543210
   15214                                                                  xxxxxxxxxx0110011xx0x1x10111x0xx
   15215                                                                  frintz.  */
   15216                                                               return 198;
   15217                                                             }
   15218                                                           else
   15219                                                             {
   15220                                                               /* 33222222222211111111110000000000
   15221                                                                  10987654321098765432109876543210
   15222                                                                  xxxxxxxxxx0110011xx0x1x10111x1xx
   15223                                                                  frinti.  */
   15224                                                               return 245;
   15225                                                             }
   15226                                                         }
   15227                                                     }
   15228                                                   else
   15229                                                     {
   15230                                                       if (((word >> 23) & 0x1) == 0)
   15231                                                         {
   15232                                                           if (((word >> 29) & 0x1) == 0)
   15233                                                             {
   15234                                                               /* 33222222222211111111110000000000
   15235                                                                  10987654321098765432109876543210
   15236                                                                  xxxxxxxxxx0110011xx1x1x00111x0xx
   15237                                                                  frintm.  */
   15238                                                               return 179;
   15239                                                             }
   15240                                                           else
   15241                                                             {
   15242                                                               /* 33222222222211111111110000000000
   15243                                                                  10987654321098765432109876543210
   15244                                                                  xxxxxxxxxx0110011xx1x1x00111x1xx
   15245                                                                  frintx.  */
   15246                                                               return 227;
   15247                                                             }
   15248                                                         }
   15249                                                       else
   15250                                                         {
   15251                                                           if (((word >> 29) & 0x1) == 0)
   15252                                                             {
   15253                                                               /* 33222222222211111111110000000000
   15254                                                                  10987654321098765432109876543210
   15255                                                                  xxxxxxxxxx0110011xx1x1x10111x0xx
   15256                                                                  frintz.  */
   15257                                                               return 199;
   15258                                                             }
   15259                                                           else
   15260                                                             {
   15261                                                               /* 33222222222211111111110000000000
   15262                                                                  10987654321098765432109876543210
   15263                                                                  xxxxxxxxxx0110011xx1x1x10111x1xx
   15264                                                                  frinti.  */
   15265                                                               return 246;
   15266                                                             }
   15267                                                         }
   15268                                                     }
   15269                                                 }
   15270                                             }
   15271                                         }
   15272                                       else
   15273                                         {
   15274                                           if (((word >> 15) & 0x1) == 0)
   15275                                             {
   15276                                               if (((word >> 28) & 0x1) == 0)
   15277                                                 {
   15278                                                   if (((word >> 19) & 0x1) == 0)
   15279                                                     {
   15280                                                       if (((word >> 29) & 0x1) == 0)
   15281                                                         {
   15282                                                           /* 33222222222211111111110000000000
   15283                                                              10987654321098765432109876543210
   15284                                                              xxxxxxxxxx011010xxx0x1xx011100xx
   15285                                                              cnt.  */
   15286                                                           return 161;
   15287                                                         }
   15288                                                       else
   15289                                                         {
   15290                                                           if (((word >> 22) & 0x1) == 0)
   15291                                                             {
   15292                                                               /* 33222222222211111111110000000000
   15293                                                                  10987654321098765432109876543210
   15294                                                                  xxxxxxxxxx011010xxx0x10x011101xx
   15295                                                                  not.  */
   15296                                                               return 236;
   15297                                                             }
   15298                                                           else
   15299                                                             {
   15300                                                               /* 33222222222211111111110000000000
   15301                                                                  10987654321098765432109876543210
   15302                                                                  xxxxxxxxxx011010xxx0x11x011101xx
   15303                                                                  rbit.  */
   15304                                                               return 238;
   15305                                                             }
   15306                                                         }
   15307                                                     }
   15308                                                   else
   15309                                                     {
   15310                                                       /* 33222222222211111111110000000000
   15311                                                          10987654321098765432109876543210
   15312                                                          xxxxxxxxxx011010xxx1x1xx01110xxx
   15313                                                          aesd.  */
   15314                                                       return 666;
   15315                                                     }
   15316                                                 }
   15317                                               else
   15318                                                 {
   15319                                                   /* 33222222222211111111110000000000
   15320                                                      10987654321098765432109876543210
   15321                                                      xxxxxxxxxx011010xxxxx1xx01111xxx
   15322                                                      fmin.  */
   15323                                                   return 832;
   15324                                                 }
   15325                                             }
   15326                                           else
   15327                                             {
   15328                                               if (((word >> 16) & 0x1) == 0)
   15329                                                 {
   15330                                                   if (((word >> 19) & 0x1) == 0)
   15331                                                     {
   15332                                                       if (((word >> 20) & 0x1) == 0)
   15333                                                         {
   15334                                                           if (((word >> 28) & 0x1) == 0)
   15335                                                             {
   15336                                                               if (((word >> 29) & 0x1) == 0)
   15337                                                                 {
   15338                                                                   /* 33222222222211111111110000000000
   15339                                                                      10987654321098765432109876543210
   15340                                                                      xxxxxxxxxx0110110xx001xx011100xx
   15341                                                                      fcmeq.  */
   15342                                                                   return 190;
   15343                                                                 }
   15344                                                               else
   15345                                                                 {
   15346                                                                   /* 33222222222211111111110000000000
   15347                                                                      10987654321098765432109876543210
   15348                                                                      xxxxxxxxxx0110110xx001xx011101xx
   15349                                                                      fcmle.  */
   15350                                                                   return 241;
   15351                                                                 }
   15352                                                             }
   15353                                                           else
   15354                                                             {
   15355                                                               if (((word >> 29) & 0x1) == 0)
   15356                                                                 {
   15357                                                                   /* 33222222222211111111110000000000
   15358                                                                      10987654321098765432109876543210
   15359                                                                      xxxxxxxxxx0110110xx001xx011110xx
   15360                                                                      fcmeq.  */
   15361                                                                   return 491;
   15362                                                                 }
   15363                                                               else
   15364                                                                 {
   15365                                                                   /* 33222222222211111111110000000000
   15366                                                                      10987654321098765432109876543210
   15367                                                                      xxxxxxxxxx0110110xx001xx011111xx
   15368                                                                      fcmle.  */
   15369                                                                   return 521;
   15370                                                                 }
   15371                                                             }
   15372                                                         }
   15373                                                       else
   15374                                                         {
   15375                                                           if (((word >> 29) & 0x1) == 0)
   15376                                                             {
   15377                                                               /* 33222222222211111111110000000000
   15378                                                                  10987654321098765432109876543210
   15379                                                                  xxxxxxxxxx0110110xx011xx0111x0xx
   15380                                                                  faddp.  */
   15381                                                               return 535;
   15382                                                             }
   15383                                                           else
   15384                                                             {
   15385                                                               /* 33222222222211111111110000000000
   15386                                                                  10987654321098765432109876543210
   15387                                                                  xxxxxxxxxx0110110xx011xx0111x1xx
   15388                                                                  faddp.  */
   15389                                                               return 534;
   15390                                                             }
   15391                                                         }
   15392                                                     }
   15393                                                   else
   15394                                                     {
   15395                                                       if (((word >> 28) & 0x1) == 0)
   15396                                                         {
   15397                                                           if (((word >> 29) & 0x1) == 0)
   15398                                                             {
   15399                                                               /* 33222222222211111111110000000000
   15400                                                                  10987654321098765432109876543210
   15401                                                                  xxxxxxxxxx0110110xx1x1xx011100xx
   15402                                                                  fcmeq.  */
   15403                                                               return 191;
   15404                                                             }
   15405                                                           else
   15406                                                             {
   15407                                                               /* 33222222222211111111110000000000
   15408                                                                  10987654321098765432109876543210
   15409                                                                  xxxxxxxxxx0110110xx1x1xx011101xx
   15410                                                                  fcmle.  */
   15411                                                               return 242;
   15412                                                             }
   15413                                                         }
   15414                                                       else
   15415                                                         {
   15416                                                           if (((word >> 29) & 0x1) == 0)
   15417                                                             {
   15418                                                               /* 33222222222211111111110000000000
   15419                                                                  10987654321098765432109876543210
   15420                                                                  xxxxxxxxxx0110110xx1x1xx011110xx
   15421                                                                  fcmeq.  */
   15422                                                               return 492;
   15423                                                             }
   15424                                                           else
   15425                                                             {
   15426                                                               /* 33222222222211111111110000000000
   15427                                                                  10987654321098765432109876543210
   15428                                                                  xxxxxxxxxx0110110xx1x1xx011111xx
   15429                                                                  fcmle.  */
   15430                                                               return 522;
   15431                                                             }
   15432                                                         }
   15433                                                     }
   15434                                                 }
   15435                                               else
   15436                                                 {
   15437                                                   if (((word >> 19) & 0x1) == 0)
   15438                                                     {
   15439                                                       if (((word >> 23) & 0x1) == 0)
   15440                                                         {
   15441                                                           if (((word >> 28) & 0x1) == 0)
   15442                                                             {
   15443                                                               if (((word >> 29) & 0x1) == 0)
   15444                                                                 {
   15445                                                                   /* 33222222222211111111110000000000
   15446                                                                      10987654321098765432109876543210
   15447                                                                      xxxxxxxxxx0110111xx0x1x0011100xx
   15448                                                                      scvtf.  */
   15449                                                                   return 186;
   15450                                                                 }
   15451                                                               else
   15452                                                                 {
   15453                                                                   /* 33222222222211111111110000000000
   15454                                                                      10987654321098765432109876543210
   15455                                                                      xxxxxxxxxx0110111xx0x1x0011101xx
   15456                                                                      ucvtf.  */
   15457                                                                   return 234;
   15458                                                                 }
   15459                                                             }
   15460                                                           else
   15461                                                             {
   15462                                                               if (((word >> 29) & 0x1) == 0)
   15463                                                                 {
   15464                                                                   /* 33222222222211111111110000000000
   15465                                                                      10987654321098765432109876543210
   15466                                                                      xxxxxxxxxx0110111xx0x1x0011110xx
   15467                                                                      scvtf.  */
   15468                                                                   return 487;
   15469                                                                 }
   15470                                                               else
   15471                                                                 {
   15472                                                                   /* 33222222222211111111110000000000
   15473                                                                      10987654321098765432109876543210
   15474                                                                      xxxxxxxxxx0110111xx0x1x0011111xx
   15475                                                                      ucvtf.  */
   15476                                                                   return 517;
   15477                                                                 }
   15478                                                             }
   15479                                                         }
   15480                                                       else
   15481                                                         {
   15482                                                           if (((word >> 28) & 0x1) == 0)
   15483                                                             {
   15484                                                               if (((word >> 29) & 0x1) == 0)
   15485                                                                 {
   15486                                                                   /* 33222222222211111111110000000000
   15487                                                                      10987654321098765432109876543210
   15488                                                                      xxxxxxxxxx0110111xx0x1x1011100xx
   15489                                                                      frecpe.  */
   15490                                                                   return 205;
   15491                                                                 }
   15492                                                               else
   15493                                                                 {
   15494                                                                   /* 33222222222211111111110000000000
   15495                                                                      10987654321098765432109876543210
   15496                                                                      xxxxxxxxxx0110111xx0x1x1011101xx
   15497                                                                      frsqrte.  */
   15498                                                                   return 252;
   15499                                                                 }
   15500                                                             }
   15501                                                           else
   15502                                                             {
   15503                                                               if (((word >> 29) & 0x1) == 0)
   15504                                                                 {
   15505                                                                   /* 33222222222211111111110000000000
   15506                                                                      10987654321098765432109876543210
   15507                                                                      xxxxxxxxxx0110111xx0x1x1011110xx
   15508                                                                      frecpe.  */
   15509                                                                   return 499;
   15510                                                                 }
   15511                                                               else
   15512                                                                 {
   15513                                                                   /* 33222222222211111111110000000000
   15514                                                                      10987654321098765432109876543210
   15515                                                                      xxxxxxxxxx0110111xx0x1x1011111xx
   15516                                                                      frsqrte.  */
   15517                                                                   return 527;
   15518                                                                 }
   15519                                                             }
   15520                                                         }
   15521                                                     }
   15522                                                   else
   15523                                                     {
   15524                                                       if (((word >> 23) & 0x1) == 0)
   15525                                                         {
   15526                                                           if (((word >> 28) & 0x1) == 0)
   15527                                                             {
   15528                                                               if (((word >> 29) & 0x1) == 0)
   15529                                                                 {
   15530                                                                   /* 33222222222211111111110000000000
   15531                                                                      10987654321098765432109876543210
   15532                                                                      xxxxxxxxxx0110111xx1x1x0011100xx
   15533                                                                      scvtf.  */
   15534                                                                   return 187;
   15535                                                                 }
   15536                                                               else
   15537                                                                 {
   15538                                                                   /* 33222222222211111111110000000000
   15539                                                                      10987654321098765432109876543210
   15540                                                                      xxxxxxxxxx0110111xx1x1x0011101xx
   15541                                                                      ucvtf.  */
   15542                                                                   return 235;
   15543                                                                 }
   15544                                                             }
   15545                                                           else
   15546                                                             {
   15547                                                               if (((word >> 29) & 0x1) == 0)
   15548                                                                 {
   15549                                                                   /* 33222222222211111111110000000000
   15550                                                                      10987654321098765432109876543210
   15551                                                                      xxxxxxxxxx0110111xx1x1x0011110xx
   15552                                                                      scvtf.  */
   15553                                                                   return 488;
   15554                                                                 }
   15555                                                               else
   15556                                                                 {
   15557                                                                   /* 33222222222211111111110000000000
   15558                                                                      10987654321098765432109876543210
   15559                                                                      xxxxxxxxxx0110111xx1x1x0011111xx
   15560                                                                      ucvtf.  */
   15561                                                                   return 518;
   15562                                                                 }
   15563                                                             }
   15564                                                         }
   15565                                                       else
   15566                                                         {
   15567                                                           if (((word >> 28) & 0x1) == 0)
   15568                                                             {
   15569                                                               if (((word >> 29) & 0x1) == 0)
   15570                                                                 {
   15571                                                                   /* 33222222222211111111110000000000
   15572                                                                      10987654321098765432109876543210
   15573                                                                      xxxxxxxxxx0110111xx1x1x1011100xx
   15574                                                                      frecpe.  */
   15575                                                                   return 206;
   15576                                                                 }
   15577                                                               else
   15578                                                                 {
   15579                                                                   /* 33222222222211111111110000000000
   15580                                                                      10987654321098765432109876543210
   15581                                                                      xxxxxxxxxx0110111xx1x1x1011101xx
   15582                                                                      frsqrte.  */
   15583                                                                   return 253;
   15584                                                                 }
   15585                                                             }
   15586                                                           else
   15587                                                             {
   15588                                                               if (((word >> 29) & 0x1) == 0)
   15589                                                                 {
   15590                                                                   /* 33222222222211111111110000000000
   15591                                                                      10987654321098765432109876543210
   15592                                                                      xxxxxxxxxx0110111xx1x1x1011110xx
   15593                                                                      frecpe.  */
   15594                                                                   return 500;
   15595                                                                 }
   15596                                                               else
   15597                                                                 {
   15598                                                                   /* 33222222222211111111110000000000
   15599                                                                      10987654321098765432109876543210
   15600                                                                      xxxxxxxxxx0110111xx1x1x1011111xx
   15601                                                                      frsqrte.  */
   15602                                                                   return 528;
   15603                                                                 }
   15604                                                             }
   15605                                                         }
   15606                                                     }
   15607                                                 }
   15608                                             }
   15609                                         }
   15610                                     }
   15611                                   else
   15612                                     {
   15613                                       if (((word >> 14) & 0x1) == 0)
   15614                                         {
   15615                                           if (((word >> 15) & 0x1) == 0)
   15616                                             {
   15617                                               if (((word >> 28) & 0x1) == 0)
   15618                                                 {
   15619                                                   if (((word >> 16) & 0x1) == 0)
   15620                                                     {
   15621                                                       if (((word >> 20) & 0x1) == 0)
   15622                                                         {
   15623                                                           if (((word >> 29) & 0x1) == 0)
   15624                                                             {
   15625                                                               /* 33222222222211111111110000000000
   15626                                                                  10987654321098765432109876543210
   15627                                                                  xxxxxxxxxx0111000xxx01xx011100xx
   15628                                                                  suqadd.  */
   15629                                                               return 159;
   15630                                                             }
   15631                                                           else
   15632                                                             {
   15633                                                               /* 33222222222211111111110000000000
   15634                                                                  10987654321098765432109876543210
   15635                                                                  xxxxxxxxxx0111000xxx01xx011101xx
   15636                                                                  usqadd.  */
   15637                                                               return 209;
   15638                                                             }
   15639                                                         }
   15640                                                       else
   15641                                                         {
   15642                                                           if (((word >> 29) & 0x1) == 0)
   15643                                                             {
   15644                                                               /* 33222222222211111111110000000000
   15645                                                                  10987654321098765432109876543210
   15646                                                                  xxxxxxxxxx0111000xxx11xx011100xx
   15647                                                                  saddlv.  */
   15648                                                               return 27;
   15649                                                             }
   15650                                                           else
   15651                                                             {
   15652                                                               /* 33222222222211111111110000000000
   15653                                                                  10987654321098765432109876543210
   15654                                                                  xxxxxxxxxx0111000xxx11xx011101xx
   15655                                                                  uaddlv.  */
   15656                                                               return 31;
   15657                                                             }
   15658                                                         }
   15659                                                     }
   15660                                                   else
   15661                                                     {
   15662                                                       if (((word >> 30) & 0x1) == 0)
   15663                                                         {
   15664                                                           /* 33222222222211111111110000000000
   15665                                                              10987654321098765432109876543210
   15666                                                              xxxxxxxxxx0111001xxxx1xx01110x0x
   15667                                                              shll.  */
   15668                                                           return 218;
   15669                                                         }
   15670                                                       else
   15671                                                         {
   15672                                                           /* 33222222222211111111110000000000
   15673                                                              10987654321098765432109876543210
   15674                                                              xxxxxxxxxx0111001xxxx1xx01110x1x
   15675                                                              shll2.  */
   15676                                                           return 219;
   15677                                                         }
   15678                                                     }
   15679                                                 }
   15680                                               else
   15681                                                 {
   15682                                                   if (((word >> 29) & 0x1) == 0)
   15683                                                     {
   15684                                                       if (((word >> 30) & 0x1) == 0)
   15685                                                         {
   15686                                                           /* 33222222222211111111110000000000
   15687                                                              10987654321098765432109876543210
   15688                                                              xxxxxxxxxx011100xxxxx1xx0111100x
   15689                                                              fsub.  */
   15690                                                           return 828;
   15691                                                         }
   15692                                                       else
   15693                                                         {
   15694                                                           /* 33222222222211111111110000000000
   15695                                                              10987654321098765432109876543210
   15696                                                              xxxxxxxxxx011100xxxxx1xx0111101x
   15697                                                              suqadd.  */
   15698                                                           return 474;
   15699                                                         }
   15700                                                     }
   15701                                                   else
   15702                                                     {
   15703                                                       /* 33222222222211111111110000000000
   15704                                                          10987654321098765432109876543210
   15705                                                          xxxxxxxxxx011100xxxxx1xx011111xx
   15706                                                          usqadd.  */
   15707                                                       return 503;
   15708                                                     }
   15709                                                 }
   15710                                             }
   15711                                           else
   15712                                             {
   15713                                               if (((word >> 16) & 0x1) == 0)
   15714                                                 {
   15715                                                   if (((word >> 28) & 0x1) == 0)
   15716                                                     {
   15717                                                       if (((word >> 29) & 0x1) == 0)
   15718                                                         {
   15719                                                           /* 33222222222211111111110000000000
   15720                                                              10987654321098765432109876543210
   15721                                                              xxxxxxxxxx0111010xxxx1xx011100xx
   15722                                                              abs.  */
   15723                                                           return 167;
   15724                                                         }
   15725                                                       else
   15726                                                         {
   15727                                                           /* 33222222222211111111110000000000
   15728                                                              10987654321098765432109876543210
   15729                                                              xxxxxxxxxx0111010xxxx1xx011101xx
   15730                                                              neg.  */
   15731                                                           return 215;
   15732                                                         }
   15733                                                     }
   15734                                                   else
   15735                                                     {
   15736                                                       if (((word >> 29) & 0x1) == 0)
   15737                                                         {
   15738                                                           /* 33222222222211111111110000000000
   15739                                                              10987654321098765432109876543210
   15740                                                              xxxxxxxxxx0111010xxxx1xx011110xx
   15741                                                              abs.  */
   15742                                                           return 479;
   15743                                                         }
   15744                                                       else
   15745                                                         {
   15746                                                           /* 33222222222211111111110000000000
   15747                                                              10987654321098765432109876543210
   15748                                                              xxxxxxxxxx0111010xxxx1xx011111xx
   15749                                                              neg.  */
   15750                                                           return 507;
   15751                                                         }
   15752                                                     }
   15753                                                 }
   15754                                               else
   15755                                                 {
   15756                                                   if (((word >> 19) & 0x1) == 0)
   15757                                                     {
   15758                                                       if (((word >> 20) & 0x1) == 0)
   15759                                                         {
   15760                                                           if (((word >> 23) & 0x1) == 0)
   15761                                                             {
   15762                                                               if (((word >> 28) & 0x1) == 0)
   15763                                                                 {
   15764                                                                   if (((word >> 29) & 0x1) == 0)
   15765                                                                     {
   15766                                                                       /* 33222222222211111111110000000000
   15767                                                                          10987654321098765432109876543210
   15768                                                                          xxxxxxxxxx0111011xx001x0011100xx
   15769                                                                          fcvtms.  */
   15770                                                                       return 182;
   15771                                                                     }
   15772                                                                   else
   15773                                                                     {
   15774                                                                       /* 33222222222211111111110000000000
   15775                                                                          10987654321098765432109876543210
   15776                                                                          xxxxxxxxxx0111011xx001x0011101xx
   15777                                                                          fcvtmu.  */
   15778                                                                       return 230;
   15779                                                                     }
   15780                                                                 }
   15781                                                               else
   15782                                                                 {
   15783                                                                   if (((word >> 29) & 0x1) == 0)
   15784                                                                     {
   15785                                                                       /* 33222222222211111111110000000000
   15786                                                                          10987654321098765432109876543210
   15787                                                                          xxxxxxxxxx0111011xx001x0011110xx
   15788                                                                          fcvtms.  */
   15789                                                                       return 483;
   15790                                                                     }
   15791                                                                   else
   15792                                                                     {
   15793                                                                       /* 33222222222211111111110000000000
   15794                                                                          10987654321098765432109876543210
   15795                                                                          xxxxxxxxxx0111011xx001x0011111xx
   15796                                                                          fcvtmu.  */
   15797                                                                       return 513;
   15798                                                                     }
   15799                                                                 }
   15800                                                             }
   15801                                                           else
   15802                                                             {
   15803                                                               if (((word >> 28) & 0x1) == 0)
   15804                                                                 {
   15805                                                                   if (((word >> 29) & 0x1) == 0)
   15806                                                                     {
   15807                                                                       /* 33222222222211111111110000000000
   15808                                                                          10987654321098765432109876543210
   15809                                                                          xxxxxxxxxx0111011xx001x1011100xx
   15810                                                                          fcvtzs.  */
   15811                                                                       return 202;
   15812                                                                     }
   15813                                                                   else
   15814                                                                     {
   15815                                                                       /* 33222222222211111111110000000000
   15816                                                                          10987654321098765432109876543210
   15817                                                                          xxxxxxxxxx0111011xx001x1011101xx
   15818                                                                          fcvtzu.  */
   15819                                                                       return 249;
   15820                                                                     }
   15821                                                                 }
   15822                                                               else
   15823                                                                 {
   15824                                                                   if (((word >> 29) & 0x1) == 0)
   15825                                                                     {
   15826                                                                       /* 33222222222211111111110000000000
   15827                                                                          10987654321098765432109876543210
   15828                                                                          xxxxxxxxxx0111011xx001x1011110xx
   15829                                                                          fcvtzs.  */
   15830                                                                       return 497;
   15831                                                                     }
   15832                                                                   else
   15833                                                                     {
   15834                                                                       /* 33222222222211111111110000000000
   15835                                                                          10987654321098765432109876543210
   15836                                                                          xxxxxxxxxx0111011xx001x1011111xx
   15837                                                                          fcvtzu.  */
   15838                                                                       return 525;
   15839                                                                     }
   15840                                                                 }
   15841                                                             }
   15842                                                         }
   15843                                                       else
   15844                                                         {
   15845                                                           if (((word >> 28) & 0x1) == 0)
   15846                                                             {
   15847                                                               /* 33222222222211111111110000000000
   15848                                                                  10987654321098765432109876543210
   15849                                                                  xxxxxxxxxx0111011xx011xx01110xxx
   15850                                                                  addv.  */
   15851                                                               return 30;
   15852                                                             }
   15853                                                           else
   15854                                                             {
   15855                                                               /* 33222222222211111111110000000000
   15856                                                                  10987654321098765432109876543210
   15857                                                                  xxxxxxxxxx0111011xx011xx01111xxx
   15858                                                                  addp.  */
   15859                                                               return 531;
   15860                                                             }
   15861                                                         }
   15862                                                     }
   15863                                                   else
   15864                                                     {
   15865                                                       if (((word >> 23) & 0x1) == 0)
   15866                                                         {
   15867                                                           if (((word >> 28) & 0x1) == 0)
   15868                                                             {
   15869                                                               if (((word >> 29) & 0x1) == 0)
   15870                                                                 {
   15871                                                                   /* 33222222222211111111110000000000
   15872                                                                      10987654321098765432109876543210
   15873                                                                      xxxxxxxxxx0111011xx1x1x0011100xx
   15874                                                                      fcvtms.  */
   15875                                                                   return 183;
   15876                                                                 }
   15877                                                               else
   15878                                                                 {
   15879                                                                   /* 33222222222211111111110000000000
   15880                                                                      10987654321098765432109876543210
   15881                                                                      xxxxxxxxxx0111011xx1x1x0011101xx
   15882                                                                      fcvtmu.  */
   15883                                                                   return 231;
   15884                                                                 }
   15885                                                             }
   15886                                                           else
   15887                                                             {
   15888                                                               if (((word >> 29) & 0x1) == 0)
   15889                                                                 {
   15890                                                                   /* 33222222222211111111110000000000
   15891                                                                      10987654321098765432109876543210
   15892                                                                      xxxxxxxxxx0111011xx1x1x0011110xx
   15893                                                                      fcvtms.  */
   15894                                                                   return 484;
   15895                                                                 }
   15896                                                               else
   15897                                                                 {
   15898                                                                   /* 33222222222211111111110000000000
   15899                                                                      10987654321098765432109876543210
   15900                                                                      xxxxxxxxxx0111011xx1x1x0011111xx
   15901                                                                      fcvtmu.  */
   15902                                                                   return 514;
   15903                                                                 }
   15904                                                             }
   15905                                                         }
   15906                                                       else
   15907                                                         {
   15908                                                           if (((word >> 28) & 0x1) == 0)
   15909                                                             {
   15910                                                               if (((word >> 29) & 0x1) == 0)
   15911                                                                 {
   15912                                                                   /* 33222222222211111111110000000000
   15913                                                                      10987654321098765432109876543210
   15914                                                                      xxxxxxxxxx0111011xx1x1x1011100xx
   15915                                                                      fcvtzs.  */
   15916                                                                   return 203;
   15917                                                                 }
   15918                                                               else
   15919                                                                 {
   15920                                                                   /* 33222222222211111111110000000000
   15921                                                                      10987654321098765432109876543210
   15922                                                                      xxxxxxxxxx0111011xx1x1x1011101xx
   15923                                                                      fcvtzu.  */
   15924                                                                   return 250;
   15925                                                                 }
   15926                                                             }
   15927                                                           else
   15928                                                             {
   15929                                                               if (((word >> 29) & 0x1) == 0)
   15930                                                                 {
   15931                                                                   /* 33222222222211111111110000000000
   15932                                                                      10987654321098765432109876543210
   15933                                                                      xxxxxxxxxx0111011xx1x1x1011110xx
   15934                                                                      fcvtzs.  */
   15935                                                                   return 498;
   15936                                                                 }
   15937                                                               else
   15938                                                                 {
   15939                                                                   /* 33222222222211111111110000000000
   15940                                                                      10987654321098765432109876543210
   15941                                                                      xxxxxxxxxx0111011xx1x1x1011111xx
   15942                                                                      fcvtzu.  */
   15943                                                                   return 526;
   15944                                                                 }
   15945                                                             }
   15946                                                         }
   15947                                                     }
   15948                                                 }
   15949                                             }
   15950                                         }
   15951                                       else
   15952                                         {
   15953                                           if (((word >> 15) & 0x1) == 0)
   15954                                             {
   15955                                               if (((word >> 28) & 0x1) == 0)
   15956                                                 {
   15957                                                   if (((word >> 16) & 0x1) == 0)
   15958                                                     {
   15959                                                       if (((word >> 19) & 0x1) == 0)
   15960                                                         {
   15961                                                           if (((word >> 29) & 0x1) == 0)
   15962                                                             {
   15963                                                               /* 33222222222211111111110000000000
   15964                                                                  10987654321098765432109876543210
   15965                                                                  xxxxxxxxxx0111100xx0x1xx011100xx
   15966                                                                  sqabs.  */
   15967                                                               return 163;
   15968                                                             }
   15969                                                           else
   15970                                                             {
   15971                                                               /* 33222222222211111111110000000000
   15972                                                                  10987654321098765432109876543210
   15973                                                                  xxxxxxxxxx0111100xx0x1xx011101xx
   15974                                                                  sqneg.  */
   15975                                                               return 212;
   15976                                                             }
   15977                                                         }
   15978                                                       else
   15979                                                         {
   15980                                                           /* 33222222222211111111110000000000
   15981                                                              10987654321098765432109876543210
   15982                                                              xxxxxxxxxx0111100xx1x1xx01110xxx
   15983                                                              aesimc.  */
   15984                                                           return 668;
   15985                                                         }
   15986                                                     }
   15987                                                   else
   15988                                                     {
   15989                                                       if (((word >> 30) & 0x1) == 0)
   15990                                                         {
   15991                                                           /* 33222222222211111111110000000000
   15992                                                              10987654321098765432109876543210
   15993                                                              xxxxxxxxxx0111101xxxx1xx01110x0x
   15994                                                              fcvtl.  */
   15995                                                           return 174;
   15996                                                         }
   15997                                                       else
   15998                                                         {
   15999                                                           /* 33222222222211111111110000000000
   16000                                                              10987654321098765432109876543210
   16001                                                              xxxxxxxxxx0111101xxxx1xx01110x1x
   16002                                                              fcvtl2.  */
   16003                                                           return 175;
   16004                                                         }
   16005                                                     }
   16006                                                 }
   16007                                               else
   16008                                                 {
   16009                                                   if (((word >> 29) & 0x1) == 0)
   16010                                                     {
   16011                                                       if (((word >> 30) & 0x1) == 0)
   16012                                                         {
   16013                                                           /* 33222222222211111111110000000000
   16014                                                              10987654321098765432109876543210
   16015                                                              xxxxxxxxxx011110xxxxx1xx0111100x
   16016                                                              fminnm.  */
   16017                                                           return 836;
   16018                                                         }
   16019                                                       else
   16020                                                         {
   16021                                                           /* 33222222222211111111110000000000
   16022                                                              10987654321098765432109876543210
   16023                                                              xxxxxxxxxx011110xxxxx1xx0111101x
   16024                                                              sqabs.  */
   16025                                                           return 475;
   16026                                                         }
   16027                                                     }
   16028                                                   else
   16029                                                     {
   16030                                                       /* 33222222222211111111110000000000
   16031                                                          10987654321098765432109876543210
   16032                                                          xxxxxxxxxx011110xxxxx1xx011111xx
   16033                                                          sqneg.  */
   16034                                                       return 504;
   16035                                                     }
   16036                                                 }
   16037                                             }
   16038                                           else
   16039                                             {
   16040                                               if (((word >> 16) & 0x1) == 0)
   16041                                                 {
   16042                                                   if (((word >> 19) & 0x1) == 0)
   16043                                                     {
   16044                                                       if (((word >> 20) & 0x1) == 0)
   16045                                                         {
   16046                                                           if (((word >> 29) & 0x1) == 0)
   16047                                                             {
   16048                                                               /* 33222222222211111111110000000000
   16049                                                                  10987654321098765432109876543210
   16050                                                                  xxxxxxxxxx0111110xx001xx0111x0xx
   16051                                                                  fabs.  */
   16052                                                               return 194;
   16053                                                             }
   16054                                                           else
   16055                                                             {
   16056                                                               /* 33222222222211111111110000000000
   16057                                                                  10987654321098765432109876543210
   16058                                                                  xxxxxxxxxx0111110xx001xx0111x1xx
   16059                                                                  fneg.  */
   16060                                                               return 243;
   16061                                                             }
   16062                                                         }
   16063                                                       else
   16064                                                         {
   16065                                                           if (((word >> 23) & 0x1) == 0)
   16066                                                             {
   16067                                                               if (((word >> 28) & 0x1) == 0)
   16068                                                                 {
   16069                                                                   if (((word >> 29) & 0x1) == 0)
   16070                                                                     {
   16071                                                                       /* 33222222222211111111110000000000
   16072                                                                          10987654321098765432109876543210
   16073                                                                          xxxxxxxxxx0111110xx011x0011100xx
   16074                                                                          fmaxv.  */
   16075                                                                       return 37;
   16076                                                                     }
   16077                                                                   else
   16078                                                                     {
   16079                                                                       /* 33222222222211111111110000000000
   16080                                                                          10987654321098765432109876543210
   16081                                                                          xxxxxxxxxx0111110xx011x0011101xx
   16082                                                                          fmaxv.  */
   16083                                                                       return 36;
   16084                                                                     }
   16085                                                                 }
   16086                                                               else
   16087                                                                 {
   16088                                                                   if (((word >> 29) & 0x1) == 0)
   16089                                                                     {
   16090                                                                       /* 33222222222211111111110000000000
   16091                                                                          10987654321098765432109876543210
   16092                                                                          xxxxxxxxxx0111110xx011x0011110xx
   16093                                                                          fmaxp.  */
   16094                                                                       return 537;
   16095                                                                     }
   16096                                                                   else
   16097                                                                     {
   16098                                                                       /* 33222222222211111111110000000000
   16099                                                                          10987654321098765432109876543210
   16100                                                                          xxxxxxxxxx0111110xx011x0011111xx
   16101                                                                          fmaxp.  */
   16102                                                                       return 536;
   16103                                                                     }
   16104                                                                 }
   16105                                                             }
   16106                                                           else
   16107                                                             {
   16108                                                               if (((word >> 28) & 0x1) == 0)
   16109                                                                 {
   16110                                                                   if (((word >> 29) & 0x1) == 0)
   16111                                                                     {
   16112                                                                       /* 33222222222211111111110000000000
   16113                                                                          10987654321098765432109876543210
   16114                                                                          xxxxxxxxxx0111110xx011x1011100xx
   16115                                                                          fminv.  */
   16116                                                                       return 41;
   16117                                                                     }
   16118                                                                   else
   16119                                                                     {
   16120                                                                       /* 33222222222211111111110000000000
   16121                                                                          10987654321098765432109876543210
   16122                                                                          xxxxxxxxxx0111110xx011x1011101xx
   16123                                                                          fminv.  */
   16124                                                                       return 40;
   16125                                                                     }
   16126                                                                 }
   16127                                                               else
   16128                                                                 {
   16129                                                                   if (((word >> 29) & 0x1) == 0)
   16130                                                                     {
   16131                                                                       /* 33222222222211111111110000000000
   16132                                                                          10987654321098765432109876543210
   16133                                                                          xxxxxxxxxx0111110xx011x1011110xx
   16134                                                                          fminp.  */
   16135                                                                       return 541;
   16136                                                                     }
   16137                                                                   else
   16138                                                                     {
   16139                                                                       /* 33222222222211111111110000000000
   16140                                                                          10987654321098765432109876543210
   16141                                                                          xxxxxxxxxx0111110xx011x1011111xx
   16142                                                                          fminp.  */
   16143                                                                       return 540;
   16144                                                                     }
   16145                                                                 }
   16146                                                             }
   16147                                                         }
   16148                                                     }
   16149                                                   else
   16150                                                     {
   16151                                                       if (((word >> 29) & 0x1) == 0)
   16152                                                         {
   16153                                                           /* 33222222222211111111110000000000
   16154                                                              10987654321098765432109876543210
   16155                                                              xxxxxxxxxx0111110xx1x1xx0111x0xx
   16156                                                              fabs.  */
   16157                                                           return 195;
   16158                                                         }
   16159                                                       else
   16160                                                         {
   16161                                                           /* 33222222222211111111110000000000
   16162                                                              10987654321098765432109876543210
   16163                                                              xxxxxxxxxx0111110xx1x1xx0111x1xx
   16164                                                              fneg.  */
   16165                                                           return 244;
   16166                                                         }
   16167                                                     }
   16168                                                 }
   16169                                               else
   16170                                                 {
   16171                                                   if (((word >> 19) & 0x1) == 0)
   16172                                                     {
   16173                                                       if (((word >> 28) & 0x1) == 0)
   16174                                                         {
   16175                                                           /* 33222222222211111111110000000000
   16176                                                              10987654321098765432109876543210
   16177                                                              xxxxxxxxxx0111111xx0x1xx01110xxx
   16178                                                              fsqrt.  */
   16179                                                           return 254;
   16180                                                         }
   16181                                                       else
   16182                                                         {
   16183                                                           /* 33222222222211111111110000000000
   16184                                                              10987654321098765432109876543210
   16185                                                              xxxxxxxxxx0111111xx0x1xx01111xxx
   16186                                                              frecpx.  */
   16187                                                           return 501;
   16188                                                         }
   16189                                                     }
   16190                                                   else
   16191                                                     {
   16192                                                       if (((word >> 28) & 0x1) == 0)
   16193                                                         {
   16194                                                           /* 33222222222211111111110000000000
   16195                                                              10987654321098765432109876543210
   16196                                                              xxxxxxxxxx0111111xx1x1xx01110xxx
   16197                                                              fsqrt.  */
   16198                                                           return 255;
   16199                                                         }
   16200                                                       else
   16201                                                         {
   16202                                                           /* 33222222222211111111110000000000
   16203                                                              10987654321098765432109876543210
   16204                                                              xxxxxxxxxx0111111xx1x1xx01111xxx
   16205                                                              frecpx.  */
   16206                                                           return 502;
   16207                                                         }
   16208                                                     }
   16209                                                 }
   16210                                             }
   16211                                         }
   16212                                     }
   16213                                 }
   16214                             }
   16215                         }
   16216                       else
   16217                         {
   16218                           if (((word >> 11) & 0x1) == 0)
   16219                             {
   16220                               if (((word >> 28) & 0x1) == 0)
   16221                                 {
   16222                                   if (((word >> 12) & 0x1) == 0)
   16223                                     {
   16224                                       if (((word >> 13) & 0x1) == 0)
   16225                                         {
   16226                                           if (((word >> 14) & 0x1) == 0)
   16227                                             {
   16228                                               if (((word >> 15) & 0x1) == 0)
   16229                                                 {
   16230                                                   if (((word >> 29) & 0x1) == 0)
   16231                                                     {
   16232                                                       /* 33222222222211111111110000000000
   16233                                                          10987654321098765432109876543210
   16234                                                          xxxxxxxxxx100000xxxxx1xx011100xx
   16235                                                          shadd.  */
   16236                                                       return 262;
   16237                                                     }
   16238                                                   else
   16239                                                     {
   16240                                                       /* 33222222222211111111110000000000
   16241                                                          10987654321098765432109876543210
   16242                                                          xxxxxxxxxx100000xxxxx1xx011101xx
   16243                                                          uhadd.  */
   16244                                                       return 314;
   16245                                                     }
   16246                                                 }
   16247                                               else
   16248                                                 {
   16249                                                   if (((word >> 29) & 0x1) == 0)
   16250                                                     {
   16251                                                       /* 33222222222211111111110000000000
   16252                                                          10987654321098765432109876543210
   16253                                                          xxxxxxxxxx100001xxxxx1xx011100xx
   16254                                                          add.  */
   16255                                                       return 277;
   16256                                                     }
   16257                                                   else
   16258                                                     {
   16259                                                       /* 33222222222211111111110000000000
   16260                                                          10987654321098765432109876543210
   16261                                                          xxxxxxxxxx100001xxxxx1xx011101xx
   16262                                                          sub.  */
   16263                                                       return 329;
   16264                                                     }
   16265                                                 }
   16266                                             }
   16267                                           else
   16268                                             {
   16269                                               if (((word >> 15) & 0x1) == 0)
   16270                                                 {
   16271                                                   if (((word >> 29) & 0x1) == 0)
   16272                                                     {
   16273                                                       /* 33222222222211111111110000000000
   16274                                                          10987654321098765432109876543210
   16275                                                          xxxxxxxxxx100010xxxxx1xx011100xx
   16276                                                          sshl.  */
   16277                                                       return 269;
   16278                                                     }
   16279                                                   else
   16280                                                     {
   16281                                                       /* 33222222222211111111110000000000
   16282                                                          10987654321098765432109876543210
   16283                                                          xxxxxxxxxx100010xxxxx1xx011101xx
   16284                                                          ushl.  */
   16285                                                       return 321;
   16286                                                     }
   16287                                                 }
   16288                                               else
   16289                                                 {
   16290                                                   if (((word >> 23) & 0x1) == 0)
   16291                                                     {
   16292                                                       if (((word >> 29) & 0x1) == 0)
   16293                                                         {
   16294                                                           /* 33222222222211111111110000000000
   16295                                                              10987654321098765432109876543210
   16296                                                              xxxxxxxxxx100011xxxxx1x0011100xx
   16297                                                              fmaxnm.  */
   16298                                                           return 285;
   16299                                                         }
   16300                                                       else
   16301                                                         {
   16302                                                           /* 33222222222211111111110000000000
   16303                                                              10987654321098765432109876543210
   16304                                                              xxxxxxxxxx100011xxxxx1x0011101xx
   16305                                                              fmaxnmp.  */
   16306                                                           return 336;
   16307                                                         }
   16308                                                     }
   16309                                                   else
   16310                                                     {
   16311                                                       if (((word >> 29) & 0x1) == 0)
   16312                                                         {
   16313                                                           /* 33222222222211111111110000000000
   16314                                                              10987654321098765432109876543210
   16315                                                              xxxxxxxxxx100011xxxxx1x1011100xx
   16316                                                              fminnm.  */
   16317                                                           return 301;
   16318                                                         }
   16319                                                       else
   16320                                                         {
   16321                                                           /* 33222222222211111111110000000000
   16322                                                              10987654321098765432109876543210
   16323                                                              xxxxxxxxxx100011xxxxx1x1011101xx
   16324                                                              fminnmp.  */
   16325                                                           return 352;
   16326                                                         }
   16327                                                     }
   16328                                                 }
   16329                                             }
   16330                                         }
   16331                                       else
   16332                                         {
   16333                                           if (((word >> 14) & 0x1) == 0)
   16334                                             {
   16335                                               if (((word >> 15) & 0x1) == 0)
   16336                                                 {
   16337                                                   if (((word >> 29) & 0x1) == 0)
   16338                                                     {
   16339                                                       /* 33222222222211111111110000000000
   16340                                                          10987654321098765432109876543210
   16341                                                          xxxxxxxxxx100100xxxxx1xx011100xx
   16342                                                          shsub.  */
   16343                                                       return 265;
   16344                                                     }
   16345                                                   else
   16346                                                     {
   16347                                                       /* 33222222222211111111110000000000
   16348                                                          10987654321098765432109876543210
   16349                                                          xxxxxxxxxx100100xxxxx1xx011101xx
   16350                                                          uhsub.  */
   16351                                                       return 317;
   16352                                                     }
   16353                                                 }
   16354                                               else
   16355                                                 {
   16356                                                   if (((word >> 29) & 0x1) == 0)
   16357                                                     {
   16358                                                       /* 33222222222211111111110000000000
   16359                                                          10987654321098765432109876543210
   16360                                                          xxxxxxxxxx100101xxxxx1xx011100xx
   16361                                                          smaxp.  */
   16362                                                       return 281;
   16363                                                     }
   16364                                                   else
   16365                                                     {
   16366                                                       /* 33222222222211111111110000000000
   16367                                                          10987654321098765432109876543210
   16368                                                          xxxxxxxxxx100101xxxxx1xx011101xx
   16369                                                          umaxp.  */
   16370                                                       return 333;
   16371                                                     }
   16372                                                 }
   16373                                             }
   16374                                           else
   16375                                             {
   16376                                               if (((word >> 15) & 0x1) == 0)
   16377                                                 {
   16378                                                   if (((word >> 29) & 0x1) == 0)
   16379                                                     {
   16380                                                       /* 33222222222211111111110000000000
   16381                                                          10987654321098765432109876543210
   16382                                                          xxxxxxxxxx100110xxxxx1xx011100xx
   16383                                                          smax.  */
   16384                                                       return 273;
   16385                                                     }
   16386                                                   else
   16387                                                     {
   16388                                                       /* 33222222222211111111110000000000
   16389                                                          10987654321098765432109876543210
   16390                                                          xxxxxxxxxx100110xxxxx1xx011101xx
   16391                                                          umax.  */
   16392                                                       return 325;
   16393                                                     }
   16394                                                 }
   16395                                               else
   16396                                                 {
   16397                                                   if (((word >> 23) & 0x1) == 0)
   16398                                                     {
   16399                                                       if (((word >> 29) & 0x1) == 0)
   16400                                                         {
   16401                                                           /* 33222222222211111111110000000000
   16402                                                              10987654321098765432109876543210
   16403                                                              xxxxxxxxxx100111xxxxx1x0011100xx
   16404                                                              fcmeq.  */
   16405                                                           return 293;
   16406                                                         }
   16407                                                       else
   16408                                                         {
   16409                                                           /* 33222222222211111111110000000000
   16410                                                              10987654321098765432109876543210
   16411                                                              xxxxxxxxxx100111xxxxx1x0011101xx
   16412                                                              fcmge.  */
   16413                                                           return 342;
   16414                                                         }
   16415                                                     }
   16416                                                   else
   16417                                                     {
   16418                                                       /* 33222222222211111111110000000000
   16419                                                          10987654321098765432109876543210
   16420                                                          xxxxxxxxxx100111xxxxx1x101110xxx
   16421                                                          fcmgt.  */
   16422                                                       return 356;
   16423                                                     }
   16424                                                 }
   16425                                             }
   16426                                         }
   16427                                     }
   16428                                   else
   16429                                     {
   16430                                       if (((word >> 13) & 0x1) == 0)
   16431                                         {
   16432                                           if (((word >> 14) & 0x1) == 0)
   16433                                             {
   16434                                               if (((word >> 15) & 0x1) == 0)
   16435                                                 {
   16436                                                   if (((word >> 29) & 0x1) == 0)
   16437                                                     {
   16438                                                       /* 33222222222211111111110000000000
   16439                                                          10987654321098765432109876543210
   16440                                                          xxxxxxxxxx101000xxxxx1xx011100xx
   16441                                                          srhadd.  */
   16442                                                       return 264;
   16443                                                     }
   16444                                                   else
   16445                                                     {
   16446                                                       /* 33222222222211111111110000000000
   16447                                                          10987654321098765432109876543210
   16448                                                          xxxxxxxxxx101000xxxxx1xx011101xx
   16449                                                          urhadd.  */
   16450                                                       return 316;
   16451                                                     }
   16452                                                 }
   16453                                               else
   16454                                                 {
   16455                                                   if (((word >> 29) & 0x1) == 0)
   16456                                                     {
   16457                                                       /* 33222222222211111111110000000000
   16458                                                          10987654321098765432109876543210
   16459                                                          xxxxxxxxxx101001xxxxx1xx011100xx
   16460                                                          mla.  */
   16461                                                       return 279;
   16462                                                     }
   16463                                                   else
   16464                                                     {
   16465                                                       /* 33222222222211111111110000000000
   16466                                                          10987654321098765432109876543210
   16467                                                          xxxxxxxxxx101001xxxxx1xx011101xx
   16468                                                          mls.  */
   16469                                                       return 331;
   16470                                                     }
   16471                                                 }
   16472                                             }
   16473                                           else
   16474                                             {
   16475                                               if (((word >> 15) & 0x1) == 0)
   16476                                                 {
   16477                                                   if (((word >> 29) & 0x1) == 0)
   16478                                                     {
   16479                                                       /* 33222222222211111111110000000000
   16480                                                          10987654321098765432109876543210
   16481                                                          xxxxxxxxxx101010xxxxx1xx011100xx
   16482                                                          srshl.  */
   16483                                                       return 271;
   16484                                                     }
   16485                                                   else
   16486                                                     {
   16487                                                       /* 33222222222211111111110000000000
   16488                                                          10987654321098765432109876543210
   16489                                                          xxxxxxxxxx101010xxxxx1xx011101xx
   16490                                                          urshl.  */
   16491                                                       return 323;
   16492                                                     }
   16493                                                 }
   16494                                               else
   16495                                                 {
   16496                                                   if (((word >> 23) & 0x1) == 0)
   16497                                                     {
   16498                                                       if (((word >> 29) & 0x1) == 0)
   16499                                                         {
   16500                                                           /* 33222222222211111111110000000000
   16501                                                              10987654321098765432109876543210
   16502                                                              xxxxxxxxxx101011xxxxx1x0011100xx
   16503                                                              fadd.  */
   16504                                                           return 289;
   16505                                                         }
   16506                                                       else
   16507                                                         {
   16508                                                           /* 33222222222211111111110000000000
   16509                                                              10987654321098765432109876543210
   16510                                                              xxxxxxxxxx101011xxxxx1x0011101xx
   16511                                                              faddp.  */
   16512                                                           return 338;
   16513                                                         }
   16514                                                     }
   16515                                                   else
   16516                                                     {
   16517                                                       if (((word >> 29) & 0x1) == 0)
   16518                                                         {
   16519                                                           /* 33222222222211111111110000000000
   16520                                                              10987654321098765432109876543210
   16521                                                              xxxxxxxxxx101011xxxxx1x1011100xx
   16522                                                              fsub.  */
   16523                                                           return 305;
   16524                                                         }
   16525                                                       else
   16526                                                         {
   16527                                                           /* 33222222222211111111110000000000
   16528                                                              10987654321098765432109876543210
   16529                                                              xxxxxxxxxx101011xxxxx1x1011101xx
   16530                                                              fabd.  */
   16531                                                           return 354;
   16532                                                         }
   16533                                                     }
   16534                                                 }
   16535                                             }
   16536                                         }
   16537                                       else
   16538                                         {
   16539                                           if (((word >> 14) & 0x1) == 0)
   16540                                             {
   16541                                               if (((word >> 15) & 0x1) == 0)
   16542                                                 {
   16543                                                   if (((word >> 29) & 0x1) == 0)
   16544                                                     {
   16545                                                       /* 33222222222211111111110000000000
   16546                                                          10987654321098765432109876543210
   16547                                                          xxxxxxxxxx101100xxxxx1xx011100xx
   16548                                                          cmgt.  */
   16549                                                       return 267;
   16550                                                     }
   16551                                                   else
   16552                                                     {
   16553                                                       /* 33222222222211111111110000000000
   16554                                                          10987654321098765432109876543210
   16555                                                          xxxxxxxxxx101100xxxxx1xx011101xx
   16556                                                          cmhi.  */
   16557                                                       return 319;
   16558                                                     }
   16559                                                 }
   16560                                               else
   16561                                                 {
   16562                                                   if (((word >> 29) & 0x1) == 0)
   16563                                                     {
   16564                                                       /* 33222222222211111111110000000000
   16565                                                          10987654321098765432109876543210
   16566                                                          xxxxxxxxxx101101xxxxx1xx011100xx
   16567                                                          sqdmulh.  */
   16568                                                       return 283;
   16569                                                     }
   16570                                                   else
   16571                                                     {
   16572                                                       /* 33222222222211111111110000000000
   16573                                                          10987654321098765432109876543210
   16574                                                          xxxxxxxxxx101101xxxxx1xx011101xx
   16575                                                          sqrdmulh.  */
   16576                                                       return 335;
   16577                                                     }
   16578                                                 }
   16579                                             }
   16580                                           else
   16581                                             {
   16582                                               if (((word >> 15) & 0x1) == 0)
   16583                                                 {
   16584                                                   if (((word >> 29) & 0x1) == 0)
   16585                                                     {
   16586                                                       /* 33222222222211111111110000000000
   16587                                                          10987654321098765432109876543210
   16588                                                          xxxxxxxxxx101110xxxxx1xx011100xx
   16589                                                          sabd.  */
   16590                                                       return 275;
   16591                                                     }
   16592                                                   else
   16593                                                     {
   16594                                                       /* 33222222222211111111110000000000
   16595                                                          10987654321098765432109876543210
   16596                                                          xxxxxxxxxx101110xxxxx1xx011101xx
   16597                                                          uabd.  */
   16598                                                       return 327;
   16599                                                     }
   16600                                                 }
   16601                                               else
   16602                                                 {
   16603                                                   if (((word >> 23) & 0x1) == 0)
   16604                                                     {
   16605                                                       if (((word >> 29) & 0x1) == 0)
   16606                                                         {
   16607                                                           /* 33222222222211111111110000000000
   16608                                                              10987654321098765432109876543210
   16609                                                              xxxxxxxxxx101111xxxxx1x0011100xx
   16610                                                              fmax.  */
   16611                                                           return 295;
   16612                                                         }
   16613                                                       else
   16614                                                         {
   16615                                                           /* 33222222222211111111110000000000
   16616                                                              10987654321098765432109876543210
   16617                                                              xxxxxxxxxx101111xxxxx1x0011101xx
   16618                                                              fmaxp.  */
   16619                                                           return 346;
   16620                                                         }
   16621                                                     }
   16622                                                   else
   16623                                                     {
   16624                                                       if (((word >> 29) & 0x1) == 0)
   16625                                                         {
   16626                                                           /* 33222222222211111111110000000000
   16627                                                              10987654321098765432109876543210
   16628                                                              xxxxxxxxxx101111xxxxx1x1011100xx
   16629                                                              fmin.  */
   16630                                                           return 307;
   16631                                                         }
   16632                                                       else
   16633                                                         {
   16634                                                           /* 33222222222211111111110000000000
   16635                                                              10987654321098765432109876543210
   16636                                                              xxxxxxxxxx101111xxxxx1x1011101xx
   16637                                                              fminp.  */
   16638                                                           return 360;
   16639                                                         }
   16640                                                     }
   16641                                                 }
   16642                                             }
   16643                                         }
   16644                                     }
   16645                                 }
   16646                               else
   16647                                 {
   16648                                   if (((word >> 29) & 0x1) == 0)
   16649                                     {
   16650                                       if (((word >> 30) & 0x1) == 0)
   16651                                         {
   16652                                           if (((word >> 4) & 0x1) == 0)
   16653                                             {
   16654                                               /* 33222222222211111111110000000000
   16655                                                  10987654321098765432109876543210
   16656                                                  xxxx0xxxxx10xxxxxxxxx1xx0111100x
   16657                                                  fccmp.  */
   16658                                               return 787;
   16659                                             }
   16660                                           else
   16661                                             {
   16662                                               /* 33222222222211111111110000000000
   16663                                                  10987654321098765432109876543210
   16664                                                  xxxx1xxxxx10xxxxxxxxx1xx0111100x
   16665                                                  fccmpe.  */
   16666                                               return 789;
   16667                                             }
   16668                                         }
   16669                                       else
   16670                                         {
   16671                                           if (((word >> 12) & 0x1) == 0)
   16672                                             {
   16673                                               if (((word >> 13) & 0x1) == 0)
   16674                                                 {
   16675                                                   if (((word >> 14) & 0x1) == 0)
   16676                                                     {
   16677                                                       /* 33222222222211111111110000000000
   16678                                                          10987654321098765432109876543210
   16679                                                          xxxxxxxxxx10000xxxxxx1xx0111101x
   16680                                                          add.  */
   16681                                                       return 559;
   16682                                                     }
   16683                                                   else
   16684                                                     {
   16685                                                       /* 33222222222211111111110000000000
   16686                                                          10987654321098765432109876543210
   16687                                                          xxxxxxxxxx10001xxxxxx1xx0111101x
   16688                                                          sshl.  */
   16689                                                       return 557;
   16690                                                     }
   16691                                                 }
   16692                                               else
   16693                                                 {
   16694                                                   /* 33222222222211111111110000000000
   16695                                                      10987654321098765432109876543210
   16696                                                      xxxxxxxxxx1001xxxxxxx1xx0111101x
   16697                                                      fcmeq.  */
   16698                                                   return 549;
   16699                                                 }
   16700                                             }
   16701                                           else
   16702                                             {
   16703                                               if (((word >> 13) & 0x1) == 0)
   16704                                                 {
   16705                                                   /* 33222222222211111111110000000000
   16706                                                      10987654321098765432109876543210
   16707                                                      xxxxxxxxxx1010xxxxxxx1xx0111101x
   16708                                                      srshl.  */
   16709                                                   return 558;
   16710                                                 }
   16711                                               else
   16712                                                 {
   16713                                                   if (((word >> 15) & 0x1) == 0)
   16714                                                     {
   16715                                                       /* 33222222222211111111110000000000
   16716                                                          10987654321098765432109876543210
   16717                                                          xxxxxxxxxx1011x0xxxxx1xx0111101x
   16718                                                          cmgt.  */
   16719                                                       return 555;
   16720                                                     }
   16721                                                   else
   16722                                                     {
   16723                                                       /* 33222222222211111111110000000000
   16724                                                          10987654321098765432109876543210
   16725                                                          xxxxxxxxxx1011x1xxxxx1xx0111101x
   16726                                                          sqdmulh.  */
   16727                                                       return 546;
   16728                                                     }
   16729                                                 }
   16730                                             }
   16731                                         }
   16732                                     }
   16733                                   else
   16734                                     {
   16735                                       if (((word >> 12) & 0x1) == 0)
   16736                                         {
   16737                                           if (((word >> 13) & 0x1) == 0)
   16738                                             {
   16739                                               if (((word >> 14) & 0x1) == 0)
   16740                                                 {
   16741                                                   /* 33222222222211111111110000000000
   16742                                                      10987654321098765432109876543210
   16743                                                      xxxxxxxxxx10000xxxxxx1xx011111xx
   16744                                                      sub.  */
   16745                                                   return 580;
   16746                                                 }
   16747                                               else
   16748                                                 {
   16749                                                   /* 33222222222211111111110000000000
   16750                                                      10987654321098765432109876543210
   16751                                                      xxxxxxxxxx10001xxxxxx1xx011111xx
   16752                                                      ushl.  */
   16753                                                   return 578;
   16754                                                 }
   16755                                             }
   16756                                           else
   16757                                             {
   16758                                               if (((word >> 23) & 0x1) == 0)
   16759                                                 {
   16760                                                   /* 33222222222211111111110000000000
   16761                                                      10987654321098765432109876543210
   16762                                                      xxxxxxxxxx1001xxxxxxx1x0011111xx
   16763                                                      fcmge.  */
   16764                                                   return 566;
   16765                                                 }
   16766                                               else
   16767                                                 {
   16768                                                   /* 33222222222211111111110000000000
   16769                                                      10987654321098765432109876543210
   16770                                                      xxxxxxxxxx1001xxxxxxx1x1011111xx
   16771                                                      fcmgt.  */
   16772                                                   return 572;
   16773                                                 }
   16774                                             }
   16775                                         }
   16776                                       else
   16777                                         {
   16778                                           if (((word >> 13) & 0x1) == 0)
   16779                                             {
   16780                                               if (((word >> 15) & 0x1) == 0)
   16781                                                 {
   16782                                                   /* 33222222222211111111110000000000
   16783                                                      10987654321098765432109876543210
   16784                                                      xxxxxxxxxx1010x0xxxxx1xx011111xx
   16785                                                      urshl.  */
   16786                                                   return 579;
   16787                                                 }
   16788                                               else
   16789                                                 {
   16790                                                   /* 33222222222211111111110000000000
   16791                                                      10987654321098765432109876543210
   16792                                                      xxxxxxxxxx1010x1xxxxx1xx011111xx
   16793                                                      fabd.  */
   16794                                                   return 570;
   16795                                                 }
   16796                                             }
   16797                                           else
   16798                                             {
   16799                                               if (((word >> 15) & 0x1) == 0)
   16800                                                 {
   16801                                                   /* 33222222222211111111110000000000
   16802                                                      10987654321098765432109876543210
   16803                                                      xxxxxxxxxx1011x0xxxxx1xx011111xx
   16804                                                      cmhi.  */
   16805                                                   return 576;
   16806                                                 }
   16807                                               else
   16808                                                 {
   16809                                                   /* 33222222222211111111110000000000
   16810                                                      10987654321098765432109876543210
   16811                                                      xxxxxxxxxx1011x1xxxxx1xx011111xx
   16812                                                      sqrdmulh.  */
   16813                                                   return 565;
   16814                                                 }
   16815                                             }
   16816                                         }
   16817                                     }
   16818                                 }
   16819                             }
   16820                           else
   16821                             {
   16822                               if (((word >> 28) & 0x1) == 0)
   16823                                 {
   16824                                   if (((word >> 12) & 0x1) == 0)
   16825                                     {
   16826                                       if (((word >> 13) & 0x1) == 0)
   16827                                         {
   16828                                           if (((word >> 14) & 0x1) == 0)
   16829                                             {
   16830                                               if (((word >> 15) & 0x1) == 0)
   16831                                                 {
   16832                                                   if (((word >> 29) & 0x1) == 0)
   16833                                                     {
   16834                                                       /* 33222222222211111111110000000000
   16835                                                          10987654321098765432109876543210
   16836                                                          xxxxxxxxxx110000xxxxx1xx011100xx
   16837                                                          sqadd.  */
   16838                                                       return 263;
   16839                                                     }
   16840                                                   else
   16841                                                     {
   16842                                                       /* 33222222222211111111110000000000
   16843                                                          10987654321098765432109876543210
   16844                                                          xxxxxxxxxx110000xxxxx1xx011101xx
   16845                                                          uqadd.  */
   16846                                                       return 315;
   16847                                                     }
   16848                                                 }
   16849                                               else
   16850                                                 {
   16851                                                   if (((word >> 29) & 0x1) == 0)
   16852                                                     {
   16853                                                       /* 33222222222211111111110000000000
   16854                                                          10987654321098765432109876543210
   16855                                                          xxxxxxxxxx110001xxxxx1xx011100xx
   16856                                                          cmtst.  */
   16857                                                       return 278;
   16858                                                     }
   16859                                                   else
   16860                                                     {
   16861                                                       /* 33222222222211111111110000000000
   16862                                                          10987654321098765432109876543210
   16863                                                          xxxxxxxxxx110001xxxxx1xx011101xx
   16864                                                          cmeq.  */
   16865                                                       return 330;
   16866                                                     }
   16867                                                 }
   16868                                             }
   16869                                           else
   16870                                             {
   16871                                               if (((word >> 15) & 0x1) == 0)
   16872                                                 {
   16873                                                   if (((word >> 29) & 0x1) == 0)
   16874                                                     {
   16875                                                       /* 33222222222211111111110000000000
   16876                                                          10987654321098765432109876543210
   16877                                                          xxxxxxxxxx110010xxxxx1xx011100xx
   16878                                                          sqshl.  */
   16879                                                       return 270;
   16880                                                     }
   16881                                                   else
   16882                                                     {
   16883                                                       /* 33222222222211111111110000000000
   16884                                                          10987654321098765432109876543210
   16885                                                          xxxxxxxxxx110010xxxxx1xx011101xx
   16886                                                          uqshl.  */
   16887                                                       return 322;
   16888                                                     }
   16889                                                 }
   16890                                               else
   16891                                                 {
   16892                                                   if (((word >> 23) & 0x1) == 0)
   16893                                                     {
   16894                                                       /* 33222222222211111111110000000000
   16895                                                          10987654321098765432109876543210
   16896                                                          xxxxxxxxxx110011xxxxx1x001110xxx
   16897                                                          fmla.  */
   16898                                                       return 287;
   16899                                                     }
   16900                                                   else
   16901                                                     {
   16902                                                       /* 33222222222211111111110000000000
   16903                                                          10987654321098765432109876543210
   16904                                                          xxxxxxxxxx110011xxxxx1x101110xxx
   16905                                                          fmls.  */
   16906                                                       return 303;
   16907                                                     }
   16908                                                 }
   16909                                             }
   16910                                         }
   16911                                       else
   16912                                         {
   16913                                           if (((word >> 14) & 0x1) == 0)
   16914                                             {
   16915                                               if (((word >> 15) & 0x1) == 0)
   16916                                                 {
   16917                                                   if (((word >> 29) & 0x1) == 0)
   16918                                                     {
   16919                                                       /* 33222222222211111111110000000000
   16920                                                          10987654321098765432109876543210
   16921                                                          xxxxxxxxxx110100xxxxx1xx011100xx
   16922                                                          sqsub.  */
   16923                                                       return 266;
   16924                                                     }
   16925                                                   else
   16926                                                     {
   16927                                                       /* 33222222222211111111110000000000
   16928                                                          10987654321098765432109876543210
   16929                                                          xxxxxxxxxx110100xxxxx1xx011101xx
   16930                                                          uqsub.  */
   16931                                                       return 318;
   16932                                                     }
   16933                                                 }
   16934                                               else
   16935                                                 {
   16936                                                   if (((word >> 29) & 0x1) == 0)
   16937                                                     {
   16938                                                       /* 33222222222211111111110000000000
   16939                                                          10987654321098765432109876543210
   16940                                                          xxxxxxxxxx110101xxxxx1xx011100xx
   16941                                                          sminp.  */
   16942                                                       return 282;
   16943                                                     }
   16944                                                   else
   16945                                                     {
   16946                                                       /* 33222222222211111111110000000000
   16947                                                          10987654321098765432109876543210
   16948                                                          xxxxxxxxxx110101xxxxx1xx011101xx
   16949                                                          uminp.  */
   16950                                                       return 334;
   16951                                                     }
   16952                                                 }
   16953                                             }
   16954                                           else
   16955                                             {
   16956                                               if (((word >> 15) & 0x1) == 0)
   16957                                                 {
   16958                                                   if (((word >> 29) & 0x1) == 0)
   16959                                                     {
   16960                                                       /* 33222222222211111111110000000000
   16961                                                          10987654321098765432109876543210
   16962                                                          xxxxxxxxxx110110xxxxx1xx011100xx
   16963                                                          smin.  */
   16964                                                       return 274;
   16965                                                     }
   16966                                                   else
   16967                                                     {
   16968                                                       /* 33222222222211111111110000000000
   16969                                                          10987654321098765432109876543210
   16970                                                          xxxxxxxxxx110110xxxxx1xx011101xx
   16971                                                          umin.  */
   16972                                                       return 326;
   16973                                                     }
   16974                                                 }
   16975                                               else
   16976                                                 {
   16977                                                   if (((word >> 23) & 0x1) == 0)
   16978                                                     {
   16979                                                       /* 33222222222211111111110000000000
   16980                                                          10987654321098765432109876543210
   16981                                                          xxxxxxxxxx110111xxxxx1x001110xxx
   16982                                                          facge.  */
   16983                                                       return 344;
   16984                                                     }
   16985                                                   else
   16986                                                     {
   16987                                                       /* 33222222222211111111110000000000
   16988                                                          10987654321098765432109876543210
   16989                                                          xxxxxxxxxx110111xxxxx1x101110xxx
   16990                                                          facgt.  */
   16991                                                       return 358;
   16992                                                     }
   16993                                                 }
   16994                                             }
   16995                                         }
   16996                                     }
   16997                                   else
   16998                                     {
   16999                                       if (((word >> 13) & 0x1) == 0)
   17000                                         {
   17001                                           if (((word >> 14) & 0x1) == 0)
   17002                                             {
   17003                                               if (((word >> 15) & 0x1) == 0)
   17004                                                 {
   17005                                                   if (((word >> 22) & 0x1) == 0)
   17006                                                     {
   17007                                                       if (((word >> 23) & 0x1) == 0)
   17008                                                         {
   17009                                                           if (((word >> 29) & 0x1) == 0)
   17010                                                             {
   17011                                                               /* 33222222222211111111110000000000
   17012                                                                  10987654321098765432109876543210
   17013                                                                  xxxxxxxxxx111000xxxxx100011100xx
   17014                                                                  and.  */
   17015                                                               return 299;
   17016                                                             }
   17017                                                           else
   17018                                                             {
   17019                                                               /* 33222222222211111111110000000000
   17020                                                                  10987654321098765432109876543210
   17021                                                                  xxxxxxxxxx111000xxxxx100011101xx
   17022                                                                  eor.  */
   17023                                                               return 350;
   17024                                                             }
   17025                                                         }
   17026                                                       else
   17027                                                         {
   17028                                                           if (((word >> 29) & 0x1) == 0)
   17029                                                             {
   17030                                                               /* 33222222222211111111110000000000
   17031                                                                  10987654321098765432109876543210
   17032                                                                  xxxxxxxxxx111000xxxxx101011100xx
   17033                                                                  orr.  */
   17034                                                               return 311;
   17035                                                             }
   17036                                                           else
   17037                                                             {
   17038                                                               /* 33222222222211111111110000000000
   17039                                                                  10987654321098765432109876543210
   17040                                                                  xxxxxxxxxx111000xxxxx101011101xx
   17041                                                                  bit.  */
   17042                                                               return 362;
   17043                                                             }
   17044                                                         }
   17045                                                     }
   17046                                                   else
   17047                                                     {
   17048                                                       if (((word >> 23) & 0x1) == 0)
   17049                                                         {
   17050                                                           if (((word >> 29) & 0x1) == 0)
   17051                                                             {
   17052                                                               /* 33222222222211111111110000000000
   17053                                                                  10987654321098765432109876543210
   17054                                                                  xxxxxxxxxx111000xxxxx110011100xx
   17055                                                                  bic.  */
   17056                                                               return 300;
   17057                                                             }
   17058                                                           else
   17059                                                             {
   17060                                                               /* 33222222222211111111110000000000
   17061                                                                  10987654321098765432109876543210
   17062                                                                  xxxxxxxxxx111000xxxxx110011101xx
   17063                                                                  bsl.  */
   17064                                                               return 351;
   17065                                                             }
   17066                                                         }
   17067                                                       else
   17068                                                         {
   17069                                                           if (((word >> 29) & 0x1) == 0)
   17070                                                             {
   17071                                                               /* 33222222222211111111110000000000
   17072                                                                  10987654321098765432109876543210
   17073                                                                  xxxxxxxxxx111000xxxxx111011100xx
   17074                                                                  orn.  */
   17075                                                               return 313;
   17076                                                             }
   17077                                                           else
   17078                                                             {
   17079                                                               /* 33222222222211111111110000000000
   17080                                                                  10987654321098765432109876543210
   17081                                                                  xxxxxxxxxx111000xxxxx111011101xx
   17082                                                                  bif.  */
   17083                                                               return 363;
   17084                                                             }
   17085                                                         }
   17086                                                     }
   17087                                                 }
   17088                                               else
   17089                                                 {
   17090                                                   if (((word >> 29) & 0x1) == 0)
   17091                                                     {
   17092                                                       /* 33222222222211111111110000000000
   17093                                                          10987654321098765432109876543210
   17094                                                          xxxxxxxxxx111001xxxxx1xx011100xx
   17095                                                          mul.  */
   17096                                                       return 280;
   17097                                                     }
   17098                                                   else
   17099                                                     {
   17100                                                       /* 33222222222211111111110000000000
   17101                                                          10987654321098765432109876543210
   17102                                                          xxxxxxxxxx111001xxxxx1xx011101xx
   17103                                                          pmul.  */
   17104                                                       return 332;
   17105                                                     }
   17106                                                 }
   17107                                             }
   17108                                           else
   17109                                             {
   17110                                               if (((word >> 15) & 0x1) == 0)
   17111                                                 {
   17112                                                   if (((word >> 29) & 0x1) == 0)
   17113                                                     {
   17114                                                       /* 33222222222211111111110000000000
   17115                                                          10987654321098765432109876543210
   17116                                                          xxxxxxxxxx111010xxxxx1xx011100xx
   17117                                                          sqrshl.  */
   17118                                                       return 272;
   17119                                                     }
   17120                                                   else
   17121                                                     {
   17122                                                       /* 33222222222211111111110000000000
   17123                                                          10987654321098765432109876543210
   17124                                                          xxxxxxxxxx111010xxxxx1xx011101xx
   17125                                                          uqrshl.  */
   17126                                                       return 324;
   17127                                                     }
   17128                                                 }
   17129                                               else
   17130                                                 {
   17131                                                   if (((word >> 29) & 0x1) == 0)
   17132                                                     {
   17133                                                       /* 33222222222211111111110000000000
   17134                                                          10987654321098765432109876543210
   17135                                                          xxxxxxxxxx111011xxxxx1xx011100xx
   17136                                                          fmulx.  */
   17137                                                       return 291;
   17138                                                     }
   17139                                                   else
   17140                                                     {
   17141                                                       /* 33222222222211111111110000000000
   17142                                                          10987654321098765432109876543210
   17143                                                          xxxxxxxxxx111011xxxxx1xx011101xx
   17144                                                          fmul.  */
   17145                                                       return 340;
   17146                                                     }
   17147                                                 }
   17148                                             }
   17149                                         }
   17150                                       else
   17151                                         {
   17152                                           if (((word >> 14) & 0x1) == 0)
   17153                                             {
   17154                                               if (((word >> 15) & 0x1) == 0)
   17155                                                 {
   17156                                                   if (((word >> 29) & 0x1) == 0)
   17157                                                     {
   17158                                                       /* 33222222222211111111110000000000
   17159                                                          10987654321098765432109876543210
   17160                                                          xxxxxxxxxx111100xxxxx1xx011100xx
   17161                                                          cmge.  */
   17162                                                       return 268;
   17163                                                     }
   17164                                                   else
   17165                                                     {
   17166                                                       /* 33222222222211111111110000000000
   17167                                                          10987654321098765432109876543210
   17168                                                          xxxxxxxxxx111100xxxxx1xx011101xx
   17169                                                          cmhs.  */
   17170                                                       return 320;
   17171                                                     }
   17172                                                 }
   17173                                               else
   17174                                                 {
   17175                                                   /* 33222222222211111111110000000000
   17176                                                      10987654321098765432109876543210
   17177                                                      xxxxxxxxxx111101xxxxx1xx01110xxx
   17178                                                      addp.  */
   17179                                                   return 284;
   17180                                                 }
   17181                                             }
   17182                                           else
   17183                                             {
   17184                                               if (((word >> 15) & 0x1) == 0)
   17185                                                 {
   17186                                                   if (((word >> 29) & 0x1) == 0)
   17187                                                     {
   17188                                                       /* 33222222222211111111110000000000
   17189                                                          10987654321098765432109876543210
   17190                                                          xxxxxxxxxx111110xxxxx1xx011100xx
   17191                                                          saba.  */
   17192                                                       return 276;
   17193                                                     }
   17194                                                   else
   17195                                                     {
   17196                                                       /* 33222222222211111111110000000000
   17197                                                          10987654321098765432109876543210
   17198                                                          xxxxxxxxxx111110xxxxx1xx011101xx
   17199                                                          uaba.  */
   17200                                                       return 328;
   17201                                                     }
   17202                                                 }
   17203                                               else
   17204                                                 {
   17205                                                   if (((word >> 23) & 0x1) == 0)
   17206                                                     {
   17207                                                       if (((word >> 29) & 0x1) == 0)
   17208                                                         {
   17209                                                           /* 33222222222211111111110000000000
   17210                                                              10987654321098765432109876543210
   17211                                                              xxxxxxxxxx111111xxxxx1x0011100xx
   17212                                                              frecps.  */
   17213                                                           return 297;
   17214                                                         }
   17215                                                       else
   17216                                                         {
   17217                                                           /* 33222222222211111111110000000000
   17218                                                              10987654321098765432109876543210
   17219                                                              xxxxxxxxxx111111xxxxx1x0011101xx
   17220                                                              fdiv.  */
   17221                                                           return 348;
   17222                                                         }
   17223                                                     }
   17224                                                   else
   17225                                                     {
   17226                                                       /* 33222222222211111111110000000000
   17227                                                          10987654321098765432109876543210
   17228                                                          xxxxxxxxxx111111xxxxx1x101110xxx
   17229                                                          frsqrts.  */
   17230                                                       return 309;
   17231                                                     }
   17232                                                 }
   17233                                             }
   17234                                         }
   17235                                     }
   17236                                 }
   17237                               else
   17238                                 {
   17239                                   if (((word >> 29) & 0x1) == 0)
   17240                                     {
   17241                                       if (((word >> 30) & 0x1) == 0)
   17242                                         {
   17243                                           /* 33222222222211111111110000000000
   17244                                              10987654321098765432109876543210
   17245                                              xxxxxxxxxx11xxxxxxxxx1xx0111100x
   17246                                              fcsel.  */
   17247                                           return 850;
   17248                                         }
   17249                                       else
   17250                                         {
   17251                                           if (((word >> 12) & 0x1) == 0)
   17252                                             {
   17253                                               if (((word >> 13) & 0x1) == 0)
   17254                                                 {
   17255                                                   if (((word >> 14) & 0x1) == 0)
   17256                                                     {
   17257                                                       if (((word >> 15) & 0x1) == 0)
   17258                                                         {
   17259                                                           /* 33222222222211111111110000000000
   17260                                                              10987654321098765432109876543210
   17261                                                              xxxxxxxxxx110000xxxxx1xx0111101x
   17262                                                              sqadd.  */
   17263                                                           return 542;
   17264                                                         }
   17265                                                       else
   17266                                                         {
   17267                                                           /* 33222222222211111111110000000000
   17268                                                              10987654321098765432109876543210
   17269                                                              xxxxxxxxxx110001xxxxx1xx0111101x
   17270                                                              cmtst.  */
   17271                                                           return 560;
   17272                                                         }
   17273                                                     }
   17274                                                   else
   17275                                                     {
   17276                                                       /* 33222222222211111111110000000000
   17277                                                          10987654321098765432109876543210
   17278                                                          xxxxxxxxxx11001xxxxxx1xx0111101x
   17279                                                          sqshl.  */
   17280                                                       return 544;
   17281                                                     }
   17282                                                 }
   17283                                               else
   17284                                                 {
   17285                                                   /* 33222222222211111111110000000000
   17286                                                      10987654321098765432109876543210
   17287                                                      xxxxxxxxxx1101xxxxxxx1xx0111101x
   17288                                                      sqsub.  */
   17289                                                   return 543;
   17290                                                 }
   17291                                             }
   17292                                           else
   17293                                             {
   17294                                               if (((word >> 13) & 0x1) == 0)
   17295                                                 {
   17296                                                   if (((word >> 15) & 0x1) == 0)
   17297                                                     {
   17298                                                       /* 33222222222211111111110000000000
   17299                                                          10987654321098765432109876543210
   17300                                                          xxxxxxxxxx1110x0xxxxx1xx0111101x
   17301                                                          sqrshl.  */
   17302                                                       return 545;
   17303                                                     }
   17304                                                   else
   17305                                                     {
   17306                                                       /* 33222222222211111111110000000000
   17307                                                          10987654321098765432109876543210
   17308                                                          xxxxxxxxxx1110x1xxxxx1xx0111101x
   17309                                                          fmulx.  */
   17310                                                       return 547;
   17311                                                     }
   17312                                                 }
   17313                                               else
   17314                                                 {
   17315                                                   if (((word >> 14) & 0x1) == 0)
   17316                                                     {
   17317                                                       /* 33222222222211111111110000000000
   17318                                                          10987654321098765432109876543210
   17319                                                          xxxxxxxxxx11110xxxxxx1xx0111101x
   17320                                                          cmge.  */
   17321                                                       return 556;
   17322                                                     }
   17323                                                   else
   17324                                                     {
   17325                                                       if (((word >> 23) & 0x1) == 0)
   17326                                                         {
   17327                                                           /* 33222222222211111111110000000000
   17328                                                              10987654321098765432109876543210
   17329                                                              xxxxxxxxxx11111xxxxxx1x00111101x
   17330                                                              frecps.  */
   17331                                                           return 551;
   17332                                                         }
   17333                                                       else
   17334                                                         {
   17335                                                           /* 33222222222211111111110000000000
   17336                                                              10987654321098765432109876543210
   17337                                                              xxxxxxxxxx11111xxxxxx1x10111101x
   17338                                                              frsqrts.  */
   17339                                                           return 553;
   17340                                                         }
   17341                                                     }
   17342                                                 }
   17343                                             }
   17344                                         }
   17345                                     }
   17346                                   else
   17347                                     {
   17348                                       if (((word >> 12) & 0x1) == 0)
   17349                                         {
   17350                                           if (((word >> 13) & 0x1) == 0)
   17351                                             {
   17352                                               if (((word >> 14) & 0x1) == 0)
   17353                                                 {
   17354                                                   if (((word >> 15) & 0x1) == 0)
   17355                                                     {
   17356                                                       /* 33222222222211111111110000000000
   17357                                                          10987654321098765432109876543210
   17358                                                          xxxxxxxxxx110000xxxxx1xx011111xx
   17359                                                          uqadd.  */
   17360                                                       return 561;
   17361                                                     }
   17362                                                   else
   17363                                                     {
   17364                                                       /* 33222222222211111111110000000000
   17365                                                          10987654321098765432109876543210
   17366                                                          xxxxxxxxxx110001xxxxx1xx011111xx
   17367                                                          cmeq.  */
   17368                                                       return 581;
   17369                                                     }
   17370                                                 }
   17371                                               else
   17372                                                 {
   17373                                                   /* 33222222222211111111110000000000
   17374                                                      10987654321098765432109876543210
   17375                                                      xxxxxxxxxx11001xxxxxx1xx011111xx
   17376                                                      uqshl.  */
   17377                                                   return 563;
   17378                                                 }
   17379                                             }
   17380                                           else
   17381                                             {
   17382                                               if (((word >> 14) & 0x1) == 0)
   17383                                                 {
   17384                                                   /* 33222222222211111111110000000000
   17385                                                      10987654321098765432109876543210
   17386                                                      xxxxxxxxxx11010xxxxxx1xx011111xx
   17387                                                      uqsub.  */
   17388                                                   return 562;
   17389                                                 }
   17390                                               else
   17391                                                 {
   17392                                                   if (((word >> 23) & 0x1) == 0)
   17393                                                     {
   17394                                                       /* 33222222222211111111110000000000
   17395                                                          10987654321098765432109876543210
   17396                                                          xxxxxxxxxx11011xxxxxx1x0011111xx
   17397                                                          facge.  */
   17398                                                       return 568;
   17399                                                     }
   17400                                                   else
   17401                                                     {
   17402                                                       /* 33222222222211111111110000000000
   17403                                                          10987654321098765432109876543210
   17404                                                          xxxxxxxxxx11011xxxxxx1x1011111xx
   17405                                                          facgt.  */
   17406                                                       return 574;
   17407                                                     }
   17408                                                 }
   17409                                             }
   17410                                         }
   17411                                       else
   17412                                         {
   17413                                           if (((word >> 13) & 0x1) == 0)
   17414                                             {
   17415                                               /* 33222222222211111111110000000000
   17416                                                  10987654321098765432109876543210
   17417                                                  xxxxxxxxxx1110xxxxxxx1xx011111xx
   17418                                                  uqrshl.  */
   17419                                               return 564;
   17420                                             }
   17421                                           else
   17422                                             {
   17423                                               /* 33222222222211111111110000000000
   17424                                                  10987654321098765432109876543210
   17425                                                  xxxxxxxxxx1111xxxxxxx1xx011111xx
   17426                                                  cmhs.  */
   17427                                               return 577;
   17428                                             }
   17429                                         }
   17430                                     }
   17431                                 }
   17432                             }
   17433                         }
   17434                     }
   17435                 }
   17436               else
   17437                 {
   17438                   if (((word >> 15) & 0x1) == 0)
   17439                     {
   17440                       if (((word >> 28) & 0x1) == 0)
   17441                         {
   17442                           if (((word >> 10) & 0x1) == 0)
   17443                             {
   17444                               if (((word >> 12) & 0x1) == 0)
   17445                                 {
   17446                                   if (((word >> 13) & 0x1) == 0)
   17447                                     {
   17448                                       if (((word >> 14) & 0x1) == 0)
   17449                                         {
   17450                                           /* 33222222222211111111110000000000
   17451                                              10987654321098765432109876543210
   17452                                              xxxxxxxxxx0x0000xxxxxxxx11110xxx
   17453                                              mla.  */
   17454                                           return 117;
   17455                                         }
   17456                                       else
   17457                                         {
   17458                                           /* 33222222222211111111110000000000
   17459                                              10987654321098765432109876543210
   17460                                              xxxxxxxxxx0x0010xxxxxxxx11110xxx
   17461                                              mls.  */
   17462                                           return 120;
   17463                                         }
   17464                                     }
   17465                                   else
   17466                                     {
   17467                                       if (((word >> 14) & 0x1) == 0)
   17468                                         {
   17469                                           if (((word >> 29) & 0x1) == 0)
   17470                                             {
   17471                                               if (((word >> 30) & 0x1) == 0)
   17472                                                 {
   17473                                                   /* 33222222222211111111110000000000
   17474                                                      10987654321098765432109876543210
   17475                                                      xxxxxxxxxx0x0100xxxxxxxx1111000x
   17476                                                      smlal.  */
   17477                                                   return 96;
   17478                                                 }
   17479                                               else
   17480                                                 {
   17481                                                   /* 33222222222211111111110000000000
   17482                                                      10987654321098765432109876543210
   17483                                                      xxxxxxxxxx0x0100xxxxxxxx1111001x
   17484                                                      smlal2.  */
   17485                                                   return 97;
   17486                                                 }
   17487                                             }
   17488                                           else
   17489                                             {
   17490                                               if (((word >> 30) & 0x1) == 0)
   17491                                                 {
   17492                                                   /* 33222222222211111111110000000000
   17493                                                      10987654321098765432109876543210
   17494                                                      xxxxxxxxxx0x0100xxxxxxxx1111010x
   17495                                                      umlal.  */
   17496                                                   return 118;
   17497                                                 }
   17498                                               else
   17499                                                 {
   17500                                                   /* 33222222222211111111110000000000
   17501                                                      10987654321098765432109876543210
   17502                                                      xxxxxxxxxx0x0100xxxxxxxx1111011x
   17503                                                      umlal2.  */
   17504                                                   return 119;
   17505                                                 }
   17506                                             }
   17507                                         }
   17508                                       else
   17509                                         {
   17510                                           if (((word >> 29) & 0x1) == 0)
   17511                                             {
   17512                                               if (((word >> 30) & 0x1) == 0)
   17513                                                 {
   17514                                                   /* 33222222222211111111110000000000
   17515                                                      10987654321098765432109876543210
   17516                                                      xxxxxxxxxx0x0110xxxxxxxx1111000x
   17517                                                      smlsl.  */
   17518                                                   return 100;
   17519                                                 }
   17520                                               else
   17521                                                 {
   17522                                                   /* 33222222222211111111110000000000
   17523                                                      10987654321098765432109876543210
   17524                                                      xxxxxxxxxx0x0110xxxxxxxx1111001x
   17525                                                      smlsl2.  */
   17526                                                   return 101;
   17527                                                 }
   17528                                             }
   17529                                           else
   17530                                             {
   17531                                               if (((word >> 30) & 0x1) == 0)
   17532                                                 {
   17533                                                   /* 33222222222211111111110000000000
   17534                                                      10987654321098765432109876543210
   17535                                                      xxxxxxxxxx0x0110xxxxxxxx1111010x
   17536                                                      umlsl.  */
   17537                                                   return 121;
   17538                                                 }
   17539                                               else
   17540                                                 {
   17541                                                   /* 33222222222211111111110000000000
   17542                                                      10987654321098765432109876543210
   17543                                                      xxxxxxxxxx0x0110xxxxxxxx1111011x
   17544                                                      umlsl2.  */
   17545                                                   return 122;
   17546                                                 }
   17547                                             }
   17548                                         }
   17549                                     }
   17550                                 }
   17551                               else
   17552                                 {
   17553                                   if (((word >> 29) & 0x1) == 0)
   17554                                     {
   17555                                       if (((word >> 13) & 0x1) == 0)
   17556                                         {
   17557                                           if (((word >> 14) & 0x1) == 0)
   17558                                             {
   17559                                               if (((word >> 23) & 0x1) == 0)
   17560                                                 {
   17561                                                   /* 33222222222211111111110000000000
   17562                                                      10987654321098765432109876543210
   17563                                                      xxxxxxxxxx0x1000xxxxxxx0111100xx
   17564                                                      fmla.  */
   17565                                                   return 112;
   17566                                                 }
   17567                                               else
   17568                                                 {
   17569                                                   /* 33222222222211111111110000000000
   17570                                                      10987654321098765432109876543210
   17571                                                      xxxxxxxxxx0x1000xxxxxxx1111100xx
   17572                                                      fmla.  */
   17573                                                   return 111;
   17574                                                 }
   17575                                             }
   17576                                           else
   17577                                             {
   17578                                               if (((word >> 23) & 0x1) == 0)
   17579                                                 {
   17580                                                   /* 33222222222211111111110000000000
   17581                                                      10987654321098765432109876543210
   17582                                                      xxxxxxxxxx0x1010xxxxxxx0111100xx
   17583                                                      fmls.  */
   17584                                                   return 114;
   17585                                                 }
   17586                                               else
   17587                                                 {
   17588                                                   /* 33222222222211111111110000000000
   17589                                                      10987654321098765432109876543210
   17590                                                      xxxxxxxxxx0x1010xxxxxxx1111100xx
   17591                                                      fmls.  */
   17592                                                   return 113;
   17593                                                 }
   17594                                             }
   17595                                         }
   17596                                       else
   17597                                         {
   17598                                           if (((word >> 14) & 0x1) == 0)
   17599                                             {
   17600                                               if (((word >> 30) & 0x1) == 0)
   17601                                                 {
   17602                                                   /* 33222222222211111111110000000000
   17603                                                      10987654321098765432109876543210
   17604                                                      xxxxxxxxxx0x1100xxxxxxxx1111000x
   17605                                                      sqdmlal.  */
   17606                                                   return 98;
   17607                                                 }
   17608                                               else
   17609                                                 {
   17610                                                   /* 33222222222211111111110000000000
   17611                                                      10987654321098765432109876543210
   17612                                                      xxxxxxxxxx0x1100xxxxxxxx1111001x
   17613                                                      sqdmlal2.  */
   17614                                                   return 99;
   17615                                                 }
   17616                                             }
   17617                                           else
   17618                                             {
   17619                                               if (((word >> 30) & 0x1) == 0)
   17620                                                 {
   17621                                                   /* 33222222222211111111110000000000
   17622                                                      10987654321098765432109876543210
   17623                                                      xxxxxxxxxx0x1110xxxxxxxx1111000x
   17624                                                      sqdmlsl.  */
   17625                                                   return 102;
   17626                                                 }
   17627                                               else
   17628                                                 {
   17629                                                   /* 33222222222211111111110000000000
   17630                                                      10987654321098765432109876543210
   17631                                                      xxxxxxxxxx0x1110xxxxxxxx1111001x
   17632                                                      sqdmlsl2.  */
   17633                                                   return 103;
   17634                                                 }
   17635                                             }
   17636                                         }
   17637                                     }
   17638                                   else
   17639                                     {
   17640                                       /* 33222222222211111111110000000000
   17641                                          10987654321098765432109876543210
   17642                                          xxxxxxxxxx0x1xx0xxxxxxxx111101xx
   17643                                          fcmla.  */
   17644                                       return 129;
   17645                                     }
   17646                                 }
   17647                             }
   17648                           else
   17649                             {
   17650                               if (((word >> 12) & 0x1) == 0)
   17651                                 {
   17652                                   if (((word >> 29) & 0x1) == 0)
   17653                                     {
   17654                                       /* 33222222222211111111110000000000
   17655                                          10987654321098765432109876543210
   17656                                          xxxxxxxxxx1x0xx0xxxxxxxx111100xx
   17657                                          movi.  */
   17658                                       return 131;
   17659                                     }
   17660                                   else
   17661                                     {
   17662                                       /* 33222222222211111111110000000000
   17663                                          10987654321098765432109876543210
   17664                                          xxxxxxxxxx1x0xx0xxxxxxxx111101xx
   17665                                          mvni.  */
   17666                                       return 139;
   17667                                     }
   17668                                 }
   17669                               else
   17670                                 {
   17671                                   if (((word >> 29) & 0x1) == 0)
   17672                                     {
   17673                                       /* 33222222222211111111110000000000
   17674                                          10987654321098765432109876543210
   17675                                          xxxxxxxxxx1x1xx0xxxxxxxx111100xx
   17676                                          orr.  */
   17677                                       return 132;
   17678                                     }
   17679                                   else
   17680                                     {
   17681                                       /* 33222222222211111111110000000000
   17682                                          10987654321098765432109876543210
   17683                                          xxxxxxxxxx1x1xx0xxxxxxxx111101xx
   17684                                          bic.  */
   17685                                       return 140;
   17686                                     }
   17687                                 }
   17688                             }
   17689                         }
   17690                       else
   17691                         {
   17692                           if (((word >> 29) & 0x1) == 0)
   17693                             {
   17694                               if (((word >> 30) & 0x1) == 0)
   17695                                 {
   17696                                   if (((word >> 21) & 0x1) == 0)
   17697                                     {
   17698                                       /* 33222222222211111111110000000000
   17699                                          10987654321098765432109876543210
   17700                                          xxxxxxxxxxxxxxx0xxxxx0xx1111100x
   17701                                          fmadd.  */
   17702                                       return 840;
   17703                                     }
   17704                                   else
   17705                                     {
   17706                                       /* 33222222222211111111110000000000
   17707                                          10987654321098765432109876543210
   17708                                          xxxxxxxxxxxxxxx0xxxxx1xx1111100x
   17709                                          fnmadd.  */
   17710                                       return 844;
   17711                                     }
   17712                                 }
   17713                               else
   17714                                 {
   17715                                   if (((word >> 10) & 0x1) == 0)
   17716                                     {
   17717                                       if (((word >> 13) & 0x1) == 0)
   17718                                         {
   17719                                           if (((word >> 14) & 0x1) == 0)
   17720                                             {
   17721                                               if (((word >> 23) & 0x1) == 0)
   17722                                                 {
   17723                                                   /* 33222222222211111111110000000000
   17724                                                      10987654321098765432109876543210
   17725                                                      xxxxxxxxxx0xx000xxxxxxx01111101x
   17726                                                      fmla.  */
   17727                                                   return 425;
   17728                                                 }
   17729                                               else
   17730                                                 {
   17731                                                   /* 33222222222211111111110000000000
   17732                                                      10987654321098765432109876543210
   17733                                                      xxxxxxxxxx0xx000xxxxxxx11111101x
   17734                                                      fmla.  */
   17735                                                   return 424;
   17736                                                 }
   17737                                             }
   17738                                           else
   17739                                             {
   17740                                               if (((word >> 23) & 0x1) == 0)
   17741                                                 {
   17742                                                   /* 33222222222211111111110000000000
   17743                                                      10987654321098765432109876543210
   17744                                                      xxxxxxxxxx0xx010xxxxxxx01111101x
   17745                                                      fmls.  */
   17746                                                   return 427;
   17747                                                 }
   17748                                               else
   17749                                                 {
   17750                                                   /* 33222222222211111111110000000000
   17751                                                      10987654321098765432109876543210
   17752                                                      xxxxxxxxxx0xx010xxxxxxx11111101x
   17753                                                      fmls.  */
   17754                                                   return 426;
   17755                                                 }
   17756                                             }
   17757                                         }
   17758                                       else
   17759                                         {
   17760                                           if (((word >> 14) & 0x1) == 0)
   17761                                             {
   17762                                               /* 33222222222211111111110000000000
   17763                                                  10987654321098765432109876543210
   17764                                                  xxxxxxxxxx0xx100xxxxxxxx1111101x
   17765                                                  sqdmlal.  */
   17766                                               return 419;
   17767                                             }
   17768                                           else
   17769                                             {
   17770                                               /* 33222222222211111111110000000000
   17771                                                  10987654321098765432109876543210
   17772                                                  xxxxxxxxxx0xx110xxxxxxxx1111101x
   17773                                                  sqdmlsl.  */
   17774                                               return 420;
   17775                                             }
   17776                                         }
   17777                                     }
   17778                                   else
   17779                                     {
   17780                                       if (((word >> 12) & 0x1) == 0)
   17781                                         {
   17782                                           if (((word >> 13) & 0x1) == 0)
   17783                                             {
   17784                                               /* 33222222222211111111110000000000
   17785                                                  10987654321098765432109876543210
   17786                                                  xxxxxxxxxx1x00x0xxxxxxxx1111101x
   17787                                                  sshr.  */
   17788                                               return 584;
   17789                                             }
   17790                                           else
   17791                                             {
   17792                                               /* 33222222222211111111110000000000
   17793                                                  10987654321098765432109876543210
   17794                                                  xxxxxxxxxx1x01x0xxxxxxxx1111101x
   17795                                                  srshr.  */
   17796                                               return 586;
   17797                                             }
   17798                                         }
   17799                                       else
   17800                                         {
   17801                                           if (((word >> 13) & 0x1) == 0)
   17802                                             {
   17803                                               if (((word >> 14) & 0x1) == 0)
   17804                                                 {
   17805                                                   /* 33222222222211111111110000000000
   17806                                                      10987654321098765432109876543210
   17807                                                      xxxxxxxxxx1x1000xxxxxxxx1111101x
   17808                                                      ssra.  */
   17809                                                   return 585;
   17810                                                 }
   17811                                               else
   17812                                                 {
   17813                                                   /* 33222222222211111111110000000000
   17814                                                      10987654321098765432109876543210
   17815                                                      xxxxxxxxxx1x1010xxxxxxxx1111101x
   17816                                                      shl.  */
   17817                                                   return 588;
   17818                                                 }
   17819                                             }
   17820                                           else
   17821                                             {
   17822                                               if (((word >> 14) & 0x1) == 0)
   17823                                                 {
   17824                                                   /* 33222222222211111111110000000000
   17825                                                      10987654321098765432109876543210
   17826                                                      xxxxxxxxxx1x1100xxxxxxxx1111101x
   17827                                                      srsra.  */
   17828                                                   return 587;
   17829                                                 }
   17830                                               else
   17831                                                 {
   17832                                                   /* 33222222222211111111110000000000
   17833                                                      10987654321098765432109876543210
   17834                                                      xxxxxxxxxx1x1110xxxxxxxx1111101x
   17835                                                      sqshl.  */
   17836                                                   return 589;
   17837                                                 }
   17838                                             }
   17839                                         }
   17840                                     }
   17841                                 }
   17842                             }
   17843                           else
   17844                             {
   17845                               if (((word >> 12) & 0x1) == 0)
   17846                                 {
   17847                                   if (((word >> 13) & 0x1) == 0)
   17848                                     {
   17849                                       if (((word >> 14) & 0x1) == 0)
   17850                                         {
   17851                                           /* 33222222222211111111110000000000
   17852                                              10987654321098765432109876543210
   17853                                              xxxxxxxxxxxx0000xxxxxxxx111111xx
   17854                                              ushr.  */
   17855                                           return 596;
   17856                                         }
   17857                                       else
   17858                                         {
   17859                                           /* 33222222222211111111110000000000
   17860                                              10987654321098765432109876543210
   17861                                              xxxxxxxxxxxx0010xxxxxxxx111111xx
   17862                                              sri.  */
   17863                                           return 600;
   17864                                         }
   17865                                     }
   17866                                   else
   17867                                     {
   17868                                       if (((word >> 14) & 0x1) == 0)
   17869                                         {
   17870                                           /* 33222222222211111111110000000000
   17871                                              10987654321098765432109876543210
   17872                                              xxxxxxxxxxxx0100xxxxxxxx111111xx
   17873                                              urshr.  */
   17874                                           return 598;
   17875                                         }
   17876                                       else
   17877                                         {
   17878                                           /* 33222222222211111111110000000000
   17879                                              10987654321098765432109876543210
   17880                                              xxxxxxxxxxxx0110xxxxxxxx111111xx
   17881                                              sqshlu.  */
   17882                                           return 602;
   17883                                         }
   17884                                     }
   17885                                 }
   17886                               else
   17887                                 {
   17888                                   if (((word >> 13) & 0x1) == 0)
   17889                                     {
   17890                                       if (((word >> 14) & 0x1) == 0)
   17891                                         {
   17892                                           /* 33222222222211111111110000000000
   17893                                              10987654321098765432109876543210
   17894                                              xxxxxxxxxxxx1000xxxxxxxx111111xx
   17895                                              usra.  */
   17896                                           return 597;
   17897                                         }
   17898                                       else
   17899                                         {
   17900                                           /* 33222222222211111111110000000000
   17901                                              10987654321098765432109876543210
   17902                                              xxxxxxxxxxxx1010xxxxxxxx111111xx
   17903                                              sli.  */
   17904                                           return 601;
   17905                                         }
   17906                                     }
   17907                                   else
   17908                                     {
   17909                                       if (((word >> 14) & 0x1) == 0)
   17910                                         {
   17911                                           /* 33222222222211111111110000000000
   17912                                              10987654321098765432109876543210
   17913                                              xxxxxxxxxxxx1100xxxxxxxx111111xx
   17914                                              ursra.  */
   17915                                           return 599;
   17916                                         }
   17917                                       else
   17918                                         {
   17919                                           /* 33222222222211111111110000000000
   17920                                              10987654321098765432109876543210
   17921                                              xxxxxxxxxxxx1110xxxxxxxx111111xx
   17922                                              uqshl.  */
   17923                                           return 603;
   17924                                         }
   17925                                     }
   17926                                 }
   17927                             }
   17928                         }
   17929                     }
   17930                   else
   17931                     {
   17932                       if (((word >> 28) & 0x1) == 0)
   17933                         {
   17934                           if (((word >> 10) & 0x1) == 0)
   17935                             {
   17936                               if (((word >> 12) & 0x1) == 0)
   17937                                 {
   17938                                   if (((word >> 13) & 0x1) == 0)
   17939                                     {
   17940                                       if (((word >> 14) & 0x1) == 0)
   17941                                         {
   17942                                           /* 33222222222211111111110000000000
   17943                                              10987654321098765432109876543210
   17944                                              xxxxxxxxxx0x0001xxxxxxxx11110xxx
   17945                                              mul.  */
   17946                                           return 104;
   17947                                         }
   17948                                       else
   17949                                         {
   17950                                           /* 33222222222211111111110000000000
   17951                                              10987654321098765432109876543210
   17952                                              xxxxxxxxxx0x0011xxxxxxxx11110xxx
   17953                                              sqdmulh.  */
   17954                                           return 109;
   17955                                         }
   17956                                     }
   17957                                   else
   17958                                     {
   17959                                       if (((word >> 29) & 0x1) == 0)
   17960                                         {
   17961                                           if (((word >> 30) & 0x1) == 0)
   17962                                             {
   17963                                               /* 33222222222211111111110000000000
   17964                                                  10987654321098765432109876543210
   17965                                                  xxxxxxxxxx0x01x1xxxxxxxx1111000x
   17966                                                  smull.  */
   17967                                               return 105;
   17968                                             }
   17969                                           else
   17970                                             {
   17971                                               /* 33222222222211111111110000000000
   17972                                                  10987654321098765432109876543210
   17973                                                  xxxxxxxxxx0x01x1xxxxxxxx1111001x
   17974                                                  smull2.  */
   17975                                               return 106;
   17976                                             }
   17977                                         }
   17978                                       else
   17979                                         {
   17980                                           if (((word >> 30) & 0x1) == 0)
   17981                                             {
   17982                                               /* 33222222222211111111110000000000
   17983                                                  10987654321098765432109876543210
   17984                                                  xxxxxxxxxx0x01x1xxxxxxxx1111010x
   17985                                                  umull.  */
   17986                                               return 123;
   17987                                             }
   17988                                           else
   17989                                             {
   17990                                               /* 33222222222211111111110000000000
   17991                                                  10987654321098765432109876543210
   17992                                                  xxxxxxxxxx0x01x1xxxxxxxx1111011x
   17993                                                  umull2.  */
   17994                                               return 124;
   17995                                             }
   17996                                         }
   17997                                     }
   17998                                 }
   17999                               else
   18000                                 {
   18001                                   if (((word >> 13) & 0x1) == 0)
   18002                                     {
   18003                                       if (((word >> 14) & 0x1) == 0)
   18004                                         {
   18005                                           if (((word >> 23) & 0x1) == 0)
   18006                                             {
   18007                                               if (((word >> 29) & 0x1) == 0)
   18008                                                 {
   18009                                                   /* 33222222222211111111110000000000
   18010                                                      10987654321098765432109876543210
   18011                                                      xxxxxxxxxx0x1001xxxxxxx0111100xx
   18012                                                      fmul.  */
   18013                                                   return 116;
   18014                                                 }
   18015                                               else
   18016                                                 {
   18017                                                   /* 33222222222211111111110000000000
   18018                                                      10987654321098765432109876543210
   18019                                                      xxxxxxxxxx0x1001xxxxxxx0111101xx
   18020                                                      fmulx.  */
   18021                                                   return 126;
   18022                                                 }
   18023                                             }
   18024                                           else
   18025                                             {
   18026                                               if (((word >> 29) & 0x1) == 0)
   18027                                                 {
   18028                                                   /* 33222222222211111111110000000000
   18029                                                      10987654321098765432109876543210
   18030                                                      xxxxxxxxxx0x1001xxxxxxx1111100xx
   18031                                                      fmul.  */
   18032                                                   return 115;
   18033                                                 }
   18034                                               else
   18035                                                 {
   18036                                                   /* 33222222222211111111110000000000
   18037                                                      10987654321098765432109876543210
   18038                                                      xxxxxxxxxx0x1001xxxxxxx1111101xx
   18039                                                      fmulx.  */
   18040                                                   return 125;
   18041                                                 }
   18042                                             }
   18043                                         }
   18044                                       else
   18045                                         {
   18046                                           if (((word >> 29) & 0x1) == 0)
   18047                                             {
   18048                                               /* 33222222222211111111110000000000
   18049                                                  10987654321098765432109876543210
   18050                                                  xxxxxxxxxx0x1011xxxxxxxx111100xx
   18051                                                  sqrdmulh.  */
   18052                                               return 110;
   18053                                             }
   18054                                           else
   18055                                             {
   18056                                               /* 33222222222211111111110000000000
   18057                                                  10987654321098765432109876543210
   18058                                                  xxxxxxxxxx0x1011xxxxxxxx111101xx
   18059                                                  sqrdmlah.  */
   18060                                               return 127;
   18061                                             }
   18062                                         }
   18063                                     }
   18064                                   else
   18065                                     {
   18066                                       if (((word >> 14) & 0x1) == 0)
   18067                                         {
   18068                                           if (((word >> 30) & 0x1) == 0)
   18069                                             {
   18070                                               /* 33222222222211111111110000000000
   18071                                                  10987654321098765432109876543210
   18072                                                  xxxxxxxxxx0x1101xxxxxxxx11110x0x
   18073                                                  sqdmull.  */
   18074                                               return 107;
   18075                                             }
   18076                                           else
   18077                                             {
   18078                                               /* 33222222222211111111110000000000
   18079                                                  10987654321098765432109876543210
   18080                                                  xxxxxxxxxx0x1101xxxxxxxx11110x1x
   18081                                                  sqdmull2.  */
   18082                                               return 108;
   18083                                             }
   18084                                         }
   18085                                       else
   18086                                         {
   18087                                           /* 33222222222211111111110000000000
   18088                                              10987654321098765432109876543210
   18089                                              xxxxxxxxxx0x1111xxxxxxxx11110xxx
   18090                                              sqrdmlsh.  */
   18091                                           return 128;
   18092                                         }
   18093                                     }
   18094                                 }
   18095                             }
   18096                           else
   18097                             {
   18098                               if (((word >> 11) & 0x1) == 0)
   18099                                 {
   18100                                   if (((word >> 14) & 0x1) == 0)
   18101                                     {
   18102                                       if (((word >> 12) & 0x1) == 0)
   18103                                         {
   18104                                           if (((word >> 29) & 0x1) == 0)
   18105                                             {
   18106                                               /* 33222222222211111111110000000000
   18107                                                  10987654321098765432109876543210
   18108                                                  xxxxxxxxxx100x01xxxxxxxx111100xx
   18109                                                  movi.  */
   18110                                               return 133;
   18111                                             }
   18112                                           else
   18113                                             {
   18114                                               /* 33222222222211111111110000000000
   18115                                                  10987654321098765432109876543210
   18116                                                  xxxxxxxxxx100x01xxxxxxxx111101xx
   18117                                                  mvni.  */
   18118                                               return 141;
   18119                                             }
   18120                                         }
   18121                                       else
   18122                                         {
   18123                                           if (((word >> 29) & 0x1) == 0)
   18124                                             {
   18125                                               /* 33222222222211111111110000000000
   18126                                                  10987654321098765432109876543210
   18127                                                  xxxxxxxxxx101x01xxxxxxxx111100xx
   18128                                                  orr.  */
   18129                                               return 134;
   18130                                             }
   18131                                           else
   18132                                             {
   18133                                               /* 33222222222211111111110000000000
   18134                                                  10987654321098765432109876543210
   18135                                                  xxxxxxxxxx101x01xxxxxxxx111101xx
   18136                                                  bic.  */
   18137                                               return 142;
   18138                                             }
   18139                                         }
   18140                                     }
   18141                                   else
   18142                                     {
   18143                                       if (((word >> 13) & 0x1) == 0)
   18144                                         {
   18145                                           if (((word >> 29) & 0x1) == 0)
   18146                                             {
   18147                                               /* 33222222222211111111110000000000
   18148                                                  10987654321098765432109876543210
   18149                                                  xxxxxxxxxx10x011xxxxxxxx111100xx
   18150                                                  movi.  */
   18151                                               return 135;
   18152                                             }
   18153                                           else
   18154                                             {
   18155                                               /* 33222222222211111111110000000000
   18156                                                  10987654321098765432109876543210
   18157                                                  xxxxxxxxxx10x011xxxxxxxx111101xx
   18158                                                  mvni.  */
   18159                                               return 143;
   18160                                             }
   18161                                         }
   18162                                       else
   18163                                         {
   18164                                           if (((word >> 12) & 0x1) == 0)
   18165                                             {
   18166                                               if (((word >> 29) & 0x1) == 0)
   18167                                                 {
   18168                                                   /* 33222222222211111111110000000000
   18169                                                      10987654321098765432109876543210
   18170                                                      xxxxxxxxxx100111xxxxxxxx111100xx
   18171                                                      movi.  */
   18172                                                   return 136;
   18173                                                 }
   18174                                               else
   18175                                                 {
   18176                                                   /* 33222222222211111111110000000000
   18177                                                      10987654321098765432109876543210
   18178                                                      xxxxxxxxxx100111xxxxxxxx111101xx
   18179                                                      movi.  */
   18180                                                   return 144;
   18181                                                 }
   18182                                             }
   18183                                           else
   18184                                             {
   18185                                               if (((word >> 29) & 0x1) == 0)
   18186                                                 {
   18187                                                   /* 33222222222211111111110000000000
   18188                                                      10987654321098765432109876543210
   18189                                                      xxxxxxxxxx101111xxxxxxxx111100xx
   18190                                                      fmov.  */
   18191                                                   return 137;
   18192                                                 }
   18193                                               else
   18194                                                 {
   18195                                                   /* 33222222222211111111110000000000
   18196                                                      10987654321098765432109876543210
   18197                                                      xxxxxxxxxx101111xxxxxxxx111101xx
   18198                                                      fmov.  */
   18199                                                   return 146;
   18200                                                 }
   18201                                             }
   18202                                         }
   18203                                     }
   18204                                 }
   18205                               else
   18206                                 {
   18207                                   if (((word >> 12) & 0x1) == 0)
   18208                                     {
   18209                                       if (((word >> 29) & 0x1) == 0)
   18210                                         {
   18211                                           if (((word >> 30) & 0x1) == 0)
   18212                                             {
   18213                                               /* 33222222222211111111110000000000
   18214                                                  10987654321098765432109876543210
   18215                                                  xxxxxxxxxx110xx1xxxxxxxx1111000x
   18216                                                  rshrn.  */
   18217                                               return 376;
   18218                                             }
   18219                                           else
   18220                                             {
   18221                                               /* 33222222222211111111110000000000
   18222                                                  10987654321098765432109876543210
   18223                                                  xxxxxxxxxx110xx1xxxxxxxx1111001x
   18224                                                  rshrn2.  */
   18225                                               return 377;
   18226                                             }
   18227                                         }
   18228                                       else
   18229                                         {
   18230                                           if (((word >> 30) & 0x1) == 0)
   18231                                             {
   18232                                               /* 33222222222211111111110000000000
   18233                                                  10987654321098765432109876543210
   18234                                                  xxxxxxxxxx110xx1xxxxxxxx1111010x
   18235                                                  sqrshrun.  */
   18236                                               return 400;
   18237                                             }
   18238                                           else
   18239                                             {
   18240                                               /* 33222222222211111111110000000000
   18241                                                  10987654321098765432109876543210
   18242                                                  xxxxxxxxxx110xx1xxxxxxxx1111011x
   18243                                                  sqrshrun2.  */
   18244                                               return 401;
   18245                                             }
   18246                                         }
   18247                                     }
   18248                                   else
   18249                                     {
   18250                                       if (((word >> 13) & 0x1) == 0)
   18251                                         {
   18252                                           if (((word >> 29) & 0x1) == 0)
   18253                                             {
   18254                                               if (((word >> 30) & 0x1) == 0)
   18255                                                 {
   18256                                                   /* 33222222222211111111110000000000
   18257                                                      10987654321098765432109876543210
   18258                                                      xxxxxxxxxx1110x1xxxxxxxx1111000x
   18259                                                      sqrshrn.  */
   18260                                                   return 380;
   18261                                                 }
   18262                                               else
   18263                                                 {
   18264                                                   /* 33222222222211111111110000000000
   18265                                                      10987654321098765432109876543210
   18266                                                      xxxxxxxxxx1110x1xxxxxxxx1111001x
   18267                                                      sqrshrn2.  */
   18268                                                   return 381;
   18269                                                 }
   18270                                             }
   18271                                           else
   18272                                             {
   18273                                               if (((word >> 30) & 0x1) == 0)
   18274                                                 {
   18275                                                   /* 33222222222211111111110000000000
   18276                                                      10987654321098765432109876543210
   18277                                                      xxxxxxxxxx1110x1xxxxxxxx1111010x
   18278                                                      uqrshrn.  */
   18279                                                   return 404;
   18280                                                 }
   18281                                               else
   18282                                                 {
   18283                                                   /* 33222222222211111111110000000000
   18284                                                      10987654321098765432109876543210
   18285                                                      xxxxxxxxxx1110x1xxxxxxxx1111011x
   18286                                                      uqrshrn2.  */
   18287                                                   return 405;
   18288                                                 }
   18289                                             }
   18290                                         }
   18291                                       else
   18292                                         {
   18293                                           if (((word >> 29) & 0x1) == 0)
   18294                                             {
   18295                                               /* 33222222222211111111110000000000
   18296                                                  10987654321098765432109876543210
   18297                                                  xxxxxxxxxx1111x1xxxxxxxx111100xx
   18298                                                  fmov.  */
   18299                                               return 138;
   18300                                             }
   18301                                           else
   18302                                             {
   18303                                               /* 33222222222211111111110000000000
   18304                                                  10987654321098765432109876543210
   18305                                                  xxxxxxxxxx1111x1xxxxxxxx111101xx
   18306                                                  fcvtzu.  */
   18307                                               return 412;
   18308                                             }
   18309                                         }
   18310                                     }
   18311                                 }
   18312                             }
   18313                         }
   18314                       else
   18315                         {
   18316                           if (((word >> 29) & 0x1) == 0)
   18317                             {
   18318                               if (((word >> 30) & 0x1) == 0)
   18319                                 {
   18320                                   if (((word >> 21) & 0x1) == 0)
   18321                                     {
   18322                                       /* 33222222222211111111110000000000
   18323                                          10987654321098765432109876543210
   18324                                          xxxxxxxxxxxxxxx1xxxxx0xx1111100x
   18325                                          fmsub.  */
   18326                                       return 842;
   18327                                     }
   18328                                   else
   18329                                     {
   18330                                       /* 33222222222211111111110000000000
   18331                                          10987654321098765432109876543210
   18332                                          xxxxxxxxxxxxxxx1xxxxx1xx1111100x
   18333                                          fnmsub.  */
   18334                                       return 846;
   18335                                     }
   18336                                 }
   18337                               else
   18338                                 {
   18339                                   if (((word >> 10) & 0x1) == 0)
   18340                                     {
   18341                                       if (((word >> 12) & 0x1) == 0)
   18342                                         {
   18343                                           /* 33222222222211111111110000000000
   18344                                              10987654321098765432109876543210
   18345                                              xxxxxxxxxx0x0xx1xxxxxxxx1111101x
   18346                                              sqdmulh.  */
   18347                                           return 422;
   18348                                         }
   18349                                       else
   18350                                         {
   18351                                           if (((word >> 13) & 0x1) == 0)
   18352                                             {
   18353                                               if (((word >> 14) & 0x1) == 0)
   18354                                                 {
   18355                                                   if (((word >> 23) & 0x1) == 0)
   18356                                                     {
   18357                                                       /* 33222222222211111111110000000000
   18358                                                          10987654321098765432109876543210
   18359                                                          xxxxxxxxxx0x1001xxxxxxx01111101x
   18360                                                          fmul.  */
   18361                                                       return 429;
   18362                                                     }
   18363                                                   else
   18364                                                     {
   18365                                                       /* 33222222222211111111110000000000
   18366                                                          10987654321098765432109876543210
   18367                                                          xxxxxxxxxx0x1001xxxxxxx11111101x
   18368                                                          fmul.  */
   18369                                                       return 428;
   18370                                                     }
   18371                                                 }
   18372                                               else
   18373                                                 {
   18374                                                   /* 33222222222211111111110000000000
   18375                                                      10987654321098765432109876543210
   18376                                                      xxxxxxxxxx0x1011xxxxxxxx1111101x
   18377                                                      sqrdmulh.  */
   18378                                                   return 423;
   18379                                                 }
   18380                                             }
   18381                                           else
   18382                                             {
   18383                                               /* 33222222222211111111110000000000
   18384                                                  10987654321098765432109876543210
   18385                                                  xxxxxxxxxx0x11x1xxxxxxxx1111101x
   18386                                                  sqdmull.  */
   18387                                               return 421;
   18388                                             }
   18389                                         }
   18390                                     }
   18391                                   else
   18392                                     {
   18393                                       if (((word >> 11) & 0x1) == 0)
   18394                                         {
   18395                                           if (((word >> 12) & 0x1) == 0)
   18396                                             {
   18397                                               /* 33222222222211111111110000000000
   18398                                                  10987654321098765432109876543210
   18399                                                  xxxxxxxxxx100xx1xxxxxxxx1111101x
   18400                                                  scvtf.  */
   18401                                               return 592;
   18402                                             }
   18403                                           else
   18404                                             {
   18405                                               /* 33222222222211111111110000000000
   18406                                                  10987654321098765432109876543210
   18407                                                  xxxxxxxxxx101xx1xxxxxxxx1111101x
   18408                                                  sqshrn.  */
   18409                                               return 590;
   18410                                             }
   18411                                         }
   18412                                       else
   18413                                         {
   18414                                           if (((word >> 13) & 0x1) == 0)
   18415                                             {
   18416                                               /* 33222222222211111111110000000000
   18417                                                  10987654321098765432109876543210
   18418                                                  xxxxxxxxxx11x0x1xxxxxxxx1111101x
   18419                                                  sqrshrn.  */
   18420                                               return 591;
   18421                                             }
   18422                                           else
   18423                                             {
   18424                                               /* 33222222222211111111110000000000
   18425                                                  10987654321098765432109876543210
   18426                                                  xxxxxxxxxx11x1x1xxxxxxxx1111101x
   18427                                                  fcvtzs.  */
   18428                                               return 594;
   18429                                             }
   18430                                         }
   18431                                     }
   18432                                 }
   18433                             }
   18434                           else
   18435                             {
   18436                               if (((word >> 10) & 0x1) == 0)
   18437                                 {
   18438                                   if (((word >> 13) & 0x1) == 0)
   18439                                     {
   18440                                       if (((word >> 14) & 0x1) == 0)
   18441                                         {
   18442                                           if (((word >> 23) & 0x1) == 0)
   18443                                             {
   18444                                               /* 33222222222211111111110000000000
   18445                                                  10987654321098765432109876543210
   18446                                                  xxxxxxxxxx0xx001xxxxxxx0111111xx
   18447                                                  fmulx.  */
   18448                                               return 431;
   18449                                             }
   18450                                           else
   18451                                             {
   18452                                               /* 33222222222211111111110000000000
   18453                                                  10987654321098765432109876543210
   18454                                                  xxxxxxxxxx0xx001xxxxxxx1111111xx
   18455                                                  fmulx.  */
   18456                                               return 430;
   18457                                             }
   18458                                         }
   18459                                       else
   18460                                         {
   18461                                           /* 33222222222211111111110000000000
   18462                                              10987654321098765432109876543210
   18463                                              xxxxxxxxxx0xx011xxxxxxxx111111xx
   18464                                              sqrdmlah.  */
   18465                                           return 432;
   18466                                         }
   18467                                     }
   18468                                   else
   18469                                     {
   18470                                       /* 33222222222211111111110000000000
   18471                                          10987654321098765432109876543210
   18472                                          xxxxxxxxxx0xx1x1xxxxxxxx111111xx
   18473                                          sqrdmlsh.  */
   18474                                       return 433;
   18475                                     }
   18476                                 }
   18477                               else
   18478                                 {
   18479                                   if (((word >> 11) & 0x1) == 0)
   18480                                     {
   18481                                       if (((word >> 12) & 0x1) == 0)
   18482                                         {
   18483                                           if (((word >> 13) & 0x1) == 0)
   18484                                             {
   18485                                               /* 33222222222211111111110000000000
   18486                                                  10987654321098765432109876543210
   18487                                                  xxxxxxxxxx1000x1xxxxxxxx111111xx
   18488                                                  sqshrun.  */
   18489                                               return 604;
   18490                                             }
   18491                                           else
   18492                                             {
   18493                                               /* 33222222222211111111110000000000
   18494                                                  10987654321098765432109876543210
   18495                                                  xxxxxxxxxx1001x1xxxxxxxx111111xx
   18496                                                  ucvtf.  */
   18497                                               return 608;
   18498                                             }
   18499                                         }
   18500                                       else
   18501                                         {
   18502                                           /* 33222222222211111111110000000000
   18503                                              10987654321098765432109876543210
   18504                                              xxxxxxxxxx101xx1xxxxxxxx111111xx
   18505                                              uqshrn.  */
   18506                                           return 606;
   18507                                         }
   18508                                     }
   18509                                   else
   18510                                     {
   18511                                       if (((word >> 12) & 0x1) == 0)
   18512                                         {
   18513                                           /* 33222222222211111111110000000000
   18514                                              10987654321098765432109876543210
   18515                                              xxxxxxxxxx110xx1xxxxxxxx111111xx
   18516                                              sqrshrun.  */
   18517                                           return 605;
   18518                                         }
   18519                                       else
   18520                                         {
   18521                                           if (((word >> 13) & 0x1) == 0)
   18522                                             {
   18523                                               /* 33222222222211111111110000000000
   18524                                                  10987654321098765432109876543210
   18525                                                  xxxxxxxxxx1110x1xxxxxxxx111111xx
   18526                                                  uqrshrn.  */
   18527                                               return 607;
   18528                                             }
   18529                                           else
   18530                                             {
   18531                                               /* 33222222222211111111110000000000
   18532                                                  10987654321098765432109876543210
   18533                                                  xxxxxxxxxx1111x1xxxxxxxx111111xx
   18534                                                  fcvtzu.  */
   18535                                               return 610;
   18536                                             }
   18537                                         }
   18538                                     }
   18539                                 }
   18540                             }
   18541                         }
   18542                     }
   18543                 }
   18544             }
   18545         }
   18546     }
   18547 }
   18548 
   18549 /* Lookup opcode WORD in the opcode table.  N.B. all alias
   18550    opcodes are ignored here.  */
   18551 
   18552 const aarch64_opcode *
   18553 aarch64_opcode_lookup (uint32_t word)
   18554 {
   18555   return aarch64_opcode_table + aarch64_opcode_lookup_1 (word);
   18556 }
   18557 
   18558 const aarch64_opcode *
   18559 aarch64_find_next_opcode (const aarch64_opcode *opcode)
   18560 {
   18561   /* Use the index as the key to locate the next opcode.  */
   18562   int key = opcode - aarch64_opcode_table;
   18563   int value;
   18564   switch (key)
   18565     {
   18566     case 941: value = 945; break;	/* stnp --> stp.  */
   18567     case 945: return NULL;		/* stp --> NULL.  */
   18568     case 939: value = 940; break;	/* stllrb --> stllrh.  */
   18569     case 940: return NULL;		/* stllrh --> NULL.  */
   18570     case 942: value = 946; break;	/* ldnp --> ldp.  */
   18571     case 946: return NULL;		/* ldp --> NULL.  */
   18572     case 1157: value = 1158; break;	/* msr --> hint.  */
   18573     case 1158: value = 1172; break;	/* hint --> clrex.  */
   18574     case 1172: value = 1173; break;	/* clrex --> dsb.  */
   18575     case 1173: value = 1174; break;	/* dsb --> dmb.  */
   18576     case 1174: value = 1175; break;	/* dmb --> isb.  */
   18577     case 1175: value = 1176; break;	/* isb --> sys.  */
   18578     case 1176: value = 1181; break;	/* sys --> msr.  */
   18579     case 1181: return NULL;		/* msr --> NULL.  */
   18580     case 1182: value = 1183; break;	/* sysl --> mrs.  */
   18581     case 1183: return NULL;		/* mrs --> NULL.  */
   18582     case 434: value = 435; break;	/* st4 --> st1.  */
   18583     case 435: value = 436; break;	/* st1 --> st2.  */
   18584     case 436: value = 437; break;	/* st2 --> st3.  */
   18585     case 437: return NULL;		/* st3 --> NULL.  */
   18586     case 442: value = 443; break;	/* st4 --> st1.  */
   18587     case 443: value = 444; break;	/* st1 --> st2.  */
   18588     case 444: value = 445; break;	/* st2 --> st3.  */
   18589     case 445: return NULL;		/* st3 --> NULL.  */
   18590     case 438: value = 439; break;	/* ld4 --> ld1.  */
   18591     case 439: value = 440; break;	/* ld1 --> ld2.  */
   18592     case 440: value = 441; break;	/* ld2 --> ld3.  */
   18593     case 441: return NULL;		/* ld3 --> NULL.  */
   18594     case 454: value = 456; break;	/* ld1 --> ld1r.  */
   18595     case 456: return NULL;		/* ld1r --> NULL.  */
   18596     case 458: value = 460; break;	/* ld2 --> ld2r.  */
   18597     case 460: return NULL;		/* ld2r --> NULL.  */
   18598     case 455: value = 457; break;	/* ld3 --> ld3r.  */
   18599     case 457: return NULL;		/* ld3r --> NULL.  */
   18600     case 459: value = 461; break;	/* ld4 --> ld4r.  */
   18601     case 461: return NULL;		/* ld4r --> NULL.  */
   18602     case 446: value = 447; break;	/* ld4 --> ld1.  */
   18603     case 447: value = 448; break;	/* ld1 --> ld2.  */
   18604     case 448: value = 449; break;	/* ld2 --> ld3.  */
   18605     case 449: return NULL;		/* ld3 --> NULL.  */
   18606     case 466: value = 468; break;	/* ld1 --> ld1r.  */
   18607     case 468: return NULL;		/* ld1r --> NULL.  */
   18608     case 467: value = 469; break;	/* ld3 --> ld3r.  */
   18609     case 469: return NULL;		/* ld3r --> NULL.  */
   18610     case 470: value = 472; break;	/* ld2 --> ld2r.  */
   18611     case 472: return NULL;		/* ld2r --> NULL.  */
   18612     case 471: value = 473; break;	/* ld4 --> ld4r.  */
   18613     case 473: return NULL;		/* ld4r --> NULL.  */
   18614     case 752: value = 753; break;	/* fcvtzs --> fcvtzs.  */
   18615     case 753: return NULL;		/* fcvtzs --> NULL.  */
   18616     case 748: value = 749; break;	/* scvtf --> scvtf.  */
   18617     case 749: return NULL;		/* scvtf --> NULL.  */
   18618     case 754: value = 755; break;	/* fcvtzu --> fcvtzu.  */
   18619     case 755: return NULL;		/* fcvtzu --> NULL.  */
   18620     case 750: value = 751; break;	/* ucvtf --> ucvtf.  */
   18621     case 751: return NULL;		/* ucvtf --> NULL.  */
   18622     case 756: value = 757; break;	/* fcvtns --> fcvtns.  */
   18623     case 757: return NULL;		/* fcvtns --> NULL.  */
   18624     case 776: value = 777; break;	/* fcvtms --> fcvtms.  */
   18625     case 777: return NULL;		/* fcvtms --> NULL.  */
   18626     case 772: value = 773; break;	/* fcvtps --> fcvtps.  */
   18627     case 773: return NULL;		/* fcvtps --> NULL.  */
   18628     case 780: value = 781; break;	/* fcvtzs --> fcvtzs.  */
   18629     case 781: return NULL;		/* fcvtzs --> NULL.  */
   18630     case 764: value = 765; break;	/* fcvtas --> fcvtas.  */
   18631     case 765: return NULL;		/* fcvtas --> NULL.  */
   18632     case 760: value = 761; break;	/* scvtf --> scvtf.  */
   18633     case 761: return NULL;		/* scvtf --> NULL.  */
   18634     case 768: value = 769; break;	/* fmov --> fmov.  */
   18635     case 769: return NULL;		/* fmov --> NULL.  */
   18636     case 758: value = 759; break;	/* fcvtnu --> fcvtnu.  */
   18637     case 759: return NULL;		/* fcvtnu --> NULL.  */
   18638     case 778: value = 779; break;	/* fcvtmu --> fcvtmu.  */
   18639     case 779: return NULL;		/* fcvtmu --> NULL.  */
   18640     case 774: value = 775; break;	/* fcvtpu --> fcvtpu.  */
   18641     case 775: return NULL;		/* fcvtpu --> NULL.  */
   18642     case 782: value = 783; break;	/* fcvtzu --> fcvtzu.  */
   18643     case 783: return NULL;		/* fcvtzu --> NULL.  */
   18644     case 766: value = 767; break;	/* fcvtau --> fcvtau.  */
   18645     case 767: return NULL;		/* fcvtau --> NULL.  */
   18646     case 762: value = 763; break;	/* ucvtf --> ucvtf.  */
   18647     case 763: return NULL;		/* ucvtf --> NULL.  */
   18648     case 770: value = 771; break;	/* fmov --> fmov.  */
   18649     case 771: return NULL;		/* fmov --> NULL.  */
   18650     case 799: value = 800; break;	/* fmov --> fmov.  */
   18651     case 800: return NULL;		/* fmov --> NULL.  */
   18652     case 808: value = 809; break;	/* frintn --> frintn.  */
   18653     case 809: return NULL;		/* frintn --> NULL.  */
   18654     case 803: value = 804; break;	/* fneg --> fneg.  */
   18655     case 804: return NULL;		/* fneg --> NULL.  */
   18656     case 812: value = 813; break;	/* frintm --> frintm.  */
   18657     case 813: return NULL;		/* frintm --> NULL.  */
   18658     case 801: value = 802; break;	/* fabs --> fabs.  */
   18659     case 802: return NULL;		/* fabs --> NULL.  */
   18660     case 810: value = 811; break;	/* frintp --> frintp.  */
   18661     case 811: return NULL;		/* frintp --> NULL.  */
   18662     case 805: value = 806; break;	/* fsqrt --> fsqrt.  */
   18663     case 806: return NULL;		/* fsqrt --> NULL.  */
   18664     case 814: value = 815; break;	/* frintz --> frintz.  */
   18665     case 815: return NULL;		/* frintz --> NULL.  */
   18666     case 816: value = 817; break;	/* frinta --> frinta.  */
   18667     case 817: return NULL;		/* frinta --> NULL.  */
   18668     case 818: value = 819; break;	/* frintx --> frintx.  */
   18669     case 819: return NULL;		/* frintx --> NULL.  */
   18670     case 820: value = 821; break;	/* frinti --> frinti.  */
   18671     case 821: return NULL;		/* frinti --> NULL.  */
   18672     case 791: value = 792; break;	/* fcmp --> fcmp.  */
   18673     case 792: return NULL;		/* fcmp --> NULL.  */
   18674     case 793: value = 794; break;	/* fcmpe --> fcmpe.  */
   18675     case 794: return NULL;		/* fcmpe --> NULL.  */
   18676     case 795: value = 796; break;	/* fcmp --> fcmp.  */
   18677     case 796: return NULL;		/* fcmp --> NULL.  */
   18678     case 797: value = 798; break;	/* fcmpe --> fcmpe.  */
   18679     case 798: return NULL;		/* fcmpe --> NULL.  */
   18680     case 848: value = 849; break;	/* fmov --> fmov.  */
   18681     case 849: return NULL;		/* fmov --> NULL.  */
   18682     case 822: value = 823; break;	/* fmul --> fmul.  */
   18683     case 823: return NULL;		/* fmul --> NULL.  */
   18684     case 838: value = 839; break;	/* fnmul --> fnmul.  */
   18685     case 839: return NULL;		/* fnmul --> NULL.  */
   18686     case 830: value = 831; break;	/* fmax --> fmax.  */
   18687     case 831: return NULL;		/* fmax --> NULL.  */
   18688     case 826: value = 827; break;	/* fadd --> fadd.  */
   18689     case 827: return NULL;		/* fadd --> NULL.  */
   18690     case 834: value = 835; break;	/* fmaxnm --> fmaxnm.  */
   18691     case 835: return NULL;		/* fmaxnm --> NULL.  */
   18692     case 824: value = 825; break;	/* fdiv --> fdiv.  */
   18693     case 825: return NULL;		/* fdiv --> NULL.  */
   18694     case 832: value = 833; break;	/* fmin --> fmin.  */
   18695     case 833: return NULL;		/* fmin --> NULL.  */
   18696     case 828: value = 829; break;	/* fsub --> fsub.  */
   18697     case 829: return NULL;		/* fsub --> NULL.  */
   18698     case 836: value = 837; break;	/* fminnm --> fminnm.  */
   18699     case 837: return NULL;		/* fminnm --> NULL.  */
   18700     case 787: value = 788; break;	/* fccmp --> fccmp.  */
   18701     case 788: return NULL;		/* fccmp --> NULL.  */
   18702     case 789: value = 790; break;	/* fccmpe --> fccmpe.  */
   18703     case 790: return NULL;		/* fccmpe --> NULL.  */
   18704     case 850: value = 851; break;	/* fcsel --> fcsel.  */
   18705     case 851: return NULL;		/* fcsel --> NULL.  */
   18706     case 131: value = 368; break;	/* movi --> sshr.  */
   18707     case 368: value = 370; break;	/* sshr --> srshr.  */
   18708     case 370: return NULL;		/* srshr --> NULL.  */
   18709     case 139: value = 390; break;	/* mvni --> ushr.  */
   18710     case 390: value = 392; break;	/* ushr --> urshr.  */
   18711     case 392: value = 394; break;	/* urshr --> sri.  */
   18712     case 394: value = 396; break;	/* sri --> sqshlu.  */
   18713     case 396: return NULL;		/* sqshlu --> NULL.  */
   18714     case 132: value = 369; break;	/* orr --> ssra.  */
   18715     case 369: value = 371; break;	/* ssra --> srsra.  */
   18716     case 371: value = 372; break;	/* srsra --> shl.  */
   18717     case 372: value = 373; break;	/* shl --> sqshl.  */
   18718     case 373: return NULL;		/* sqshl --> NULL.  */
   18719     case 140: value = 391; break;	/* bic --> usra.  */
   18720     case 391: value = 393; break;	/* usra --> ursra.  */
   18721     case 393: value = 395; break;	/* ursra --> sli.  */
   18722     case 395: value = 397; break;	/* sli --> uqshl.  */
   18723     case 397: return NULL;		/* uqshl --> NULL.  */
   18724     case 840: value = 841; break;	/* fmadd --> fmadd.  */
   18725     case 841: return NULL;		/* fmadd --> NULL.  */
   18726     case 844: value = 845; break;	/* fnmadd --> fnmadd.  */
   18727     case 845: return NULL;		/* fnmadd --> NULL.  */
   18728     case 133: value = 374; break;	/* movi --> shrn.  */
   18729     case 374: value = 375; break;	/* shrn --> shrn2.  */
   18730     case 375: value = 382; break;	/* shrn2 --> sshll.  */
   18731     case 382: value = 384; break;	/* sshll --> sshll2.  */
   18732     case 384: return NULL;		/* sshll2 --> NULL.  */
   18733     case 141: value = 398; break;	/* mvni --> sqshrun.  */
   18734     case 398: value = 399; break;	/* sqshrun --> sqshrun2.  */
   18735     case 399: value = 406; break;	/* sqshrun2 --> ushll.  */
   18736     case 406: value = 408; break;	/* ushll --> ushll2.  */
   18737     case 408: return NULL;		/* ushll2 --> NULL.  */
   18738     case 134: value = 378; break;	/* orr --> sqshrn.  */
   18739     case 378: value = 379; break;	/* sqshrn --> sqshrn2.  */
   18740     case 379: return NULL;		/* sqshrn2 --> NULL.  */
   18741     case 142: value = 402; break;	/* bic --> uqshrn.  */
   18742     case 402: value = 403; break;	/* uqshrn --> uqshrn2.  */
   18743     case 403: return NULL;		/* uqshrn2 --> NULL.  */
   18744     case 136: value = 386; break;	/* movi --> scvtf.  */
   18745     case 386: value = 387; break;	/* scvtf --> scvtf.  */
   18746     case 387: return NULL;		/* scvtf --> NULL.  */
   18747     case 144: value = 145; break;	/* movi --> movi.  */
   18748     case 145: value = 410; break;	/* movi --> ucvtf.  */
   18749     case 410: value = 411; break;	/* ucvtf --> ucvtf.  */
   18750     case 411: return NULL;		/* ucvtf --> NULL.  */
   18751     case 138: value = 388; break;	/* fmov --> fcvtzs.  */
   18752     case 388: value = 389; break;	/* fcvtzs --> fcvtzs.  */
   18753     case 389: return NULL;		/* fcvtzs --> NULL.  */
   18754     case 412: value = 413; break;	/* fcvtzu --> fcvtzu.  */
   18755     case 413: return NULL;		/* fcvtzu --> NULL.  */
   18756     case 842: value = 843; break;	/* fmsub --> fmsub.  */
   18757     case 843: return NULL;		/* fmsub --> NULL.  */
   18758     case 846: value = 847; break;	/* fnmsub --> fnmsub.  */
   18759     case 847: return NULL;		/* fnmsub --> NULL.  */
   18760     case 592: value = 593; break;	/* scvtf --> scvtf.  */
   18761     case 593: return NULL;		/* scvtf --> NULL.  */
   18762     case 594: value = 595; break;	/* fcvtzs --> fcvtzs.  */
   18763     case 595: return NULL;		/* fcvtzs --> NULL.  */
   18764     case 608: value = 609; break;	/* ucvtf --> ucvtf.  */
   18765     case 609: return NULL;		/* ucvtf --> NULL.  */
   18766     case 610: value = 611; break;	/* fcvtzu --> fcvtzu.  */
   18767     case 611: return NULL;		/* fcvtzu --> NULL.  */
   18768     default: return NULL;
   18769     }
   18770 
   18771   return aarch64_opcode_table + value;
   18772 }
   18773 
   18774 const aarch64_opcode *
   18775 aarch64_find_alias_opcode (const aarch64_opcode *opcode)
   18776 {
   18777   /* Use the index as the key to locate the alias opcode.  */
   18778   int key = opcode - aarch64_opcode_table;
   18779   int value;
   18780   switch (key)
   18781     {
   18782     case 2: value = 3; break;	/* sbc --> ngc.  */
   18783     case 4: value = 5; break;	/* sbcs --> ngcs.  */
   18784     case 7: value = 8; break;	/* adds --> cmn.  */
   18785     case 10: value = 11; break;	/* subs --> cmp.  */
   18786     case 12: value = 13; break;	/* add --> mov.  */
   18787     case 14: value = 15; break;	/* adds --> cmn.  */
   18788     case 17: value = 18; break;	/* subs --> cmp.  */
   18789     case 20: value = 21; break;	/* adds --> cmn.  */
   18790     case 22: value = 23; break;	/* sub --> neg.  */
   18791     case 24: value = 26; break;	/* subs --> negs.  */
   18792     case 150: value = 151; break;	/* umov --> mov.  */
   18793     case 152: value = 153; break;	/* ins --> mov.  */
   18794     case 154: value = 155; break;	/* ins --> mov.  */
   18795     case 236: value = 237; break;	/* not --> mvn.  */
   18796     case 311: value = 312; break;	/* orr --> mov.  */
   18797     case 382: value = 383; break;	/* sshll --> sxtl.  */
   18798     case 384: value = 385; break;	/* sshll2 --> sxtl2.  */
   18799     case 406: value = 407; break;	/* ushll --> uxtl.  */
   18800     case 408: value = 409; break;	/* ushll2 --> uxtl2.  */
   18801     case 529: value = 530; break;	/* dup --> mov.  */
   18802     case 612: value = 617; break;	/* sbfm --> sxtw.  */
   18803     case 619: value = 621; break;	/* bfm --> bfc.  */
   18804     case 623: value = 627; break;	/* ubfm --> uxth.  */
   18805     case 657: value = 659; break;	/* csinc --> cset.  */
   18806     case 660: value = 662; break;	/* csinv --> csetm.  */
   18807     case 663: value = 664; break;	/* csneg --> cneg.  */
   18808     case 682: value = 682; break;	/* rev --> rev.  */
   18809     case 707: value = 708; break;	/* lslv --> lsl.  */
   18810     case 709: value = 710; break;	/* lsrv --> lsr.  */
   18811     case 711: value = 712; break;	/* asrv --> asr.  */
   18812     case 713: value = 714; break;	/* rorv --> ror.  */
   18813     case 724: value = 725; break;	/* madd --> mul.  */
   18814     case 726: value = 727; break;	/* msub --> mneg.  */
   18815     case 728: value = 729; break;	/* smaddl --> smull.  */
   18816     case 730: value = 731; break;	/* smsubl --> smnegl.  */
   18817     case 733: value = 734; break;	/* umaddl --> umull.  */
   18818     case 735: value = 736; break;	/* umsubl --> umnegl.  */
   18819     case 746: value = 747; break;	/* extr --> ror.  */
   18820     case 959: value = 960; break;	/* and --> bic.  */
   18821     case 961: value = 962; break;	/* orr --> mov.  */
   18822     case 964: value = 965; break;	/* ands --> tst.  */
   18823     case 968: value = 970; break;	/* orr --> uxtw.  */
   18824     case 971: value = 972; break;	/* orn --> mvn.  */
   18825     case 975: value = 976; break;	/* ands --> tst.  */
   18826     case 1006: value = 1102; break;	/* ldaddb --> staddb.  */
   18827     case 1007: value = 1103; break;	/* ldaddh --> staddh.  */
   18828     case 1008: value = 1104; break;	/* ldadd --> stadd.  */
   18829     case 1010: value = 1105; break;	/* ldaddlb --> staddlb.  */
   18830     case 1013: value = 1106; break;	/* ldaddlh --> staddlh.  */
   18831     case 1016: value = 1107; break;	/* ldaddl --> staddl.  */
   18832     case 1018: value = 1108; break;	/* ldclrb --> stclrb.  */
   18833     case 1019: value = 1109; break;	/* ldclrh --> stclrh.  */
   18834     case 1020: value = 1110; break;	/* ldclr --> stclr.  */
   18835     case 1022: value = 1111; break;	/* ldclrlb --> stclrlb.  */
   18836     case 1025: value = 1112; break;	/* ldclrlh --> stclrlh.  */
   18837     case 1028: value = 1113; break;	/* ldclrl --> stclrl.  */
   18838     case 1030: value = 1114; break;	/* ldeorb --> steorb.  */
   18839     case 1031: value = 1115; break;	/* ldeorh --> steorh.  */
   18840     case 1032: value = 1116; break;	/* ldeor --> steor.  */
   18841     case 1034: value = 1117; break;	/* ldeorlb --> steorlb.  */
   18842     case 1037: value = 1118; break;	/* ldeorlh --> steorlh.  */
   18843     case 1040: value = 1119; break;	/* ldeorl --> steorl.  */
   18844     case 1042: value = 1120; break;	/* ldsetb --> stsetb.  */
   18845     case 1043: value = 1121; break;	/* ldseth --> stseth.  */
   18846     case 1044: value = 1122; break;	/* ldset --> stset.  */
   18847     case 1046: value = 1123; break;	/* ldsetlb --> stsetlb.  */
   18848     case 1049: value = 1124; break;	/* ldsetlh --> stsetlh.  */
   18849     case 1052: value = 1125; break;	/* ldsetl --> stsetl.  */
   18850     case 1054: value = 1126; break;	/* ldsmaxb --> stsmaxb.  */
   18851     case 1055: value = 1127; break;	/* ldsmaxh --> stsmaxh.  */
   18852     case 1056: value = 1128; break;	/* ldsmax --> stsmax.  */
   18853     case 1058: value = 1129; break;	/* ldsmaxlb --> stsmaxlb.  */
   18854     case 1061: value = 1130; break;	/* ldsmaxlh --> stsmaxlh.  */
   18855     case 1064: value = 1131; break;	/* ldsmaxl --> stsmaxl.  */
   18856     case 1066: value = 1132; break;	/* ldsminb --> stsminb.  */
   18857     case 1067: value = 1133; break;	/* ldsminh --> stsminh.  */
   18858     case 1068: value = 1134; break;	/* ldsmin --> stsmin.  */
   18859     case 1070: value = 1135; break;	/* ldsminlb --> stsminlb.  */
   18860     case 1073: value = 1136; break;	/* ldsminlh --> stsminlh.  */
   18861     case 1076: value = 1137; break;	/* ldsminl --> stsminl.  */
   18862     case 1078: value = 1138; break;	/* ldumaxb --> stumaxb.  */
   18863     case 1079: value = 1139; break;	/* ldumaxh --> stumaxh.  */
   18864     case 1080: value = 1140; break;	/* ldumax --> stumax.  */
   18865     case 1082: value = 1141; break;	/* ldumaxlb --> stumaxlb.  */
   18866     case 1085: value = 1142; break;	/* ldumaxlh --> stumaxlh.  */
   18867     case 1088: value = 1143; break;	/* ldumaxl --> stumaxl.  */
   18868     case 1090: value = 1144; break;	/* lduminb --> stuminb.  */
   18869     case 1091: value = 1145; break;	/* lduminh --> stuminh.  */
   18870     case 1092: value = 1146; break;	/* ldumin --> stumin.  */
   18871     case 1094: value = 1147; break;	/* lduminlb --> stuminlb.  */
   18872     case 1097: value = 1148; break;	/* lduminlh --> stuminlh.  */
   18873     case 1100: value = 1149; break;	/* lduminl --> stuminl.  */
   18874     case 1150: value = 1151; break;	/* movn --> mov.  */
   18875     case 1152: value = 1153; break;	/* movz --> mov.  */
   18876     case 1158: value = 1191; break;	/* hint --> autibsp.  */
   18877     case 1176: value = 1180; break;	/* sys --> tlbi.  */
   18878     case 1239: value = 1973; break;	/* and --> bic.  */
   18879     case 1241: value = 1222; break;	/* and --> mov.  */
   18880     case 1242: value = 1226; break;	/* ands --> movs.  */
   18881     case 1277: value = 1974; break;	/* cmpge --> cmple.  */
   18882     case 1280: value = 1977; break;	/* cmpgt --> cmplt.  */
   18883     case 1282: value = 1975; break;	/* cmphi --> cmplo.  */
   18884     case 1285: value = 1976; break;	/* cmphs --> cmpls.  */
   18885     case 1307: value = 1219; break;	/* cpy --> mov.  */
   18886     case 1308: value = 1221; break;	/* cpy --> mov.  */
   18887     case 1309: value = 1984; break;	/* cpy --> fmov.  */
   18888     case 1321: value = 1214; break;	/* dup --> mov.  */
   18889     case 1322: value = 1216; break;	/* dup --> mov.  */
   18890     case 1323: value = 1983; break;	/* dup --> fmov.  */
   18891     case 1324: value = 1217; break;	/* dupm --> mov.  */
   18892     case 1326: value = 1978; break;	/* eor --> eon.  */
   18893     case 1328: value = 1227; break;	/* eor --> not.  */
   18894     case 1329: value = 1228; break;	/* eors --> nots.  */
   18895     case 1334: value = 1979; break;	/* facge --> facle.  */
   18896     case 1335: value = 1980; break;	/* facgt --> faclt.  */
   18897     case 1348: value = 1981; break;	/* fcmge --> fcmle.  */
   18898     case 1350: value = 1982; break;	/* fcmgt --> fcmlt.  */
   18899     case 1356: value = 1211; break;	/* fcpy --> fmov.  */
   18900     case 1379: value = 1210; break;	/* fdup --> fmov.  */
   18901     case 1694: value = 1212; break;	/* orr --> mov.  */
   18902     case 1695: value = 1985; break;	/* orr --> orn.  */
   18903     case 1697: value = 1215; break;	/* orr --> mov.  */
   18904     case 1698: value = 1225; break;	/* orrs --> movs.  */
   18905     case 1760: value = 1220; break;	/* sel --> mov.  */
   18906     case 1761: value = 1223; break;	/* sel --> mov.  */
   18907     default: return NULL;
   18908     }
   18909 
   18910   return aarch64_opcode_table + value;
   18911 }
   18912 
   18913 const aarch64_opcode *
   18914 aarch64_find_next_alias_opcode (const aarch64_opcode *opcode)
   18915 {
   18916   /* Use the index as the key to locate the next opcode.  */
   18917   int key = opcode - aarch64_opcode_table;
   18918   int value;
   18919   switch (key)
   18920     {
   18921     case 3: value = 2; break;	/* ngc --> sbc.  */
   18922     case 5: value = 4; break;	/* ngcs --> sbcs.  */
   18923     case 8: value = 7; break;	/* cmn --> adds.  */
   18924     case 11: value = 10; break;	/* cmp --> subs.  */
   18925     case 13: value = 12; break;	/* mov --> add.  */
   18926     case 15: value = 14; break;	/* cmn --> adds.  */
   18927     case 18: value = 17; break;	/* cmp --> subs.  */
   18928     case 21: value = 20; break;	/* cmn --> adds.  */
   18929     case 23: value = 22; break;	/* neg --> sub.  */
   18930     case 26: value = 25; break;	/* negs --> cmp.  */
   18931     case 25: value = 24; break;	/* cmp --> subs.  */
   18932     case 151: value = 150; break;	/* mov --> umov.  */
   18933     case 153: value = 152; break;	/* mov --> ins.  */
   18934     case 155: value = 154; break;	/* mov --> ins.  */
   18935     case 237: value = 236; break;	/* mvn --> not.  */
   18936     case 312: value = 311; break;	/* mov --> orr.  */
   18937     case 383: value = 382; break;	/* sxtl --> sshll.  */
   18938     case 385: value = 384; break;	/* sxtl2 --> sshll2.  */
   18939     case 407: value = 406; break;	/* uxtl --> ushll.  */
   18940     case 409: value = 408; break;	/* uxtl2 --> ushll2.  */
   18941     case 530: value = 529; break;	/* mov --> dup.  */
   18942     case 617: value = 616; break;	/* sxtw --> sxth.  */
   18943     case 616: value = 615; break;	/* sxth --> sxtb.  */
   18944     case 615: value = 618; break;	/* sxtb --> asr.  */
   18945     case 618: value = 614; break;	/* asr --> sbfx.  */
   18946     case 614: value = 613; break;	/* sbfx --> sbfiz.  */
   18947     case 613: value = 612; break;	/* sbfiz --> sbfm.  */
   18948     case 621: value = 622; break;	/* bfc --> bfxil.  */
   18949     case 622: value = 620; break;	/* bfxil --> bfi.  */
   18950     case 620: value = 619; break;	/* bfi --> bfm.  */
   18951     case 627: value = 626; break;	/* uxth --> uxtb.  */
   18952     case 626: value = 629; break;	/* uxtb --> lsr.  */
   18953     case 629: value = 628; break;	/* lsr --> lsl.  */
   18954     case 628: value = 625; break;	/* lsl --> ubfx.  */
   18955     case 625: value = 624; break;	/* ubfx --> ubfiz.  */
   18956     case 624: value = 623; break;	/* ubfiz --> ubfm.  */
   18957     case 659: value = 658; break;	/* cset --> cinc.  */
   18958     case 658: value = 657; break;	/* cinc --> csinc.  */
   18959     case 662: value = 661; break;	/* csetm --> cinv.  */
   18960     case 661: value = 660; break;	/* cinv --> csinv.  */
   18961     case 664: value = 663; break;	/* cneg --> csneg.  */
   18962     case 682: value = 683; break;	/* rev --> rev64.  */
   18963     case 708: value = 707; break;	/* lsl --> lslv.  */
   18964     case 710: value = 709; break;	/* lsr --> lsrv.  */
   18965     case 712: value = 711; break;	/* asr --> asrv.  */
   18966     case 714: value = 713; break;	/* ror --> rorv.  */
   18967     case 725: value = 724; break;	/* mul --> madd.  */
   18968     case 727: value = 726; break;	/* mneg --> msub.  */
   18969     case 729: value = 728; break;	/* smull --> smaddl.  */
   18970     case 731: value = 730; break;	/* smnegl --> smsubl.  */
   18971     case 734: value = 733; break;	/* umull --> umaddl.  */
   18972     case 736: value = 735; break;	/* umnegl --> umsubl.  */
   18973     case 747: value = 746; break;	/* ror --> extr.  */
   18974     case 960: value = 959; break;	/* bic --> and.  */
   18975     case 962: value = 961; break;	/* mov --> orr.  */
   18976     case 965: value = 964; break;	/* tst --> ands.  */
   18977     case 970: value = 969; break;	/* uxtw --> mov.  */
   18978     case 969: value = 968; break;	/* mov --> orr.  */
   18979     case 972: value = 971; break;	/* mvn --> orn.  */
   18980     case 976: value = 975; break;	/* tst --> ands.  */
   18981     case 1102: value = 1006; break;	/* staddb --> ldaddb.  */
   18982     case 1103: value = 1007; break;	/* staddh --> ldaddh.  */
   18983     case 1104: value = 1008; break;	/* stadd --> ldadd.  */
   18984     case 1105: value = 1010; break;	/* staddlb --> ldaddlb.  */
   18985     case 1106: value = 1013; break;	/* staddlh --> ldaddlh.  */
   18986     case 1107: value = 1016; break;	/* staddl --> ldaddl.  */
   18987     case 1108: value = 1018; break;	/* stclrb --> ldclrb.  */
   18988     case 1109: value = 1019; break;	/* stclrh --> ldclrh.  */
   18989     case 1110: value = 1020; break;	/* stclr --> ldclr.  */
   18990     case 1111: value = 1022; break;	/* stclrlb --> ldclrlb.  */
   18991     case 1112: value = 1025; break;	/* stclrlh --> ldclrlh.  */
   18992     case 1113: value = 1028; break;	/* stclrl --> ldclrl.  */
   18993     case 1114: value = 1030; break;	/* steorb --> ldeorb.  */
   18994     case 1115: value = 1031; break;	/* steorh --> ldeorh.  */
   18995     case 1116: value = 1032; break;	/* steor --> ldeor.  */
   18996     case 1117: value = 1034; break;	/* steorlb --> ldeorlb.  */
   18997     case 1118: value = 1037; break;	/* steorlh --> ldeorlh.  */
   18998     case 1119: value = 1040; break;	/* steorl --> ldeorl.  */
   18999     case 1120: value = 1042; break;	/* stsetb --> ldsetb.  */
   19000     case 1121: value = 1043; break;	/* stseth --> ldseth.  */
   19001     case 1122: value = 1044; break;	/* stset --> ldset.  */
   19002     case 1123: value = 1046; break;	/* stsetlb --> ldsetlb.  */
   19003     case 1124: value = 1049; break;	/* stsetlh --> ldsetlh.  */
   19004     case 1125: value = 1052; break;	/* stsetl --> ldsetl.  */
   19005     case 1126: value = 1054; break;	/* stsmaxb --> ldsmaxb.  */
   19006     case 1127: value = 1055; break;	/* stsmaxh --> ldsmaxh.  */
   19007     case 1128: value = 1056; break;	/* stsmax --> ldsmax.  */
   19008     case 1129: value = 1058; break;	/* stsmaxlb --> ldsmaxlb.  */
   19009     case 1130: value = 1061; break;	/* stsmaxlh --> ldsmaxlh.  */
   19010     case 1131: value = 1064; break;	/* stsmaxl --> ldsmaxl.  */
   19011     case 1132: value = 1066; break;	/* stsminb --> ldsminb.  */
   19012     case 1133: value = 1067; break;	/* stsminh --> ldsminh.  */
   19013     case 1134: value = 1068; break;	/* stsmin --> ldsmin.  */
   19014     case 1135: value = 1070; break;	/* stsminlb --> ldsminlb.  */
   19015     case 1136: value = 1073; break;	/* stsminlh --> ldsminlh.  */
   19016     case 1137: value = 1076; break;	/* stsminl --> ldsminl.  */
   19017     case 1138: value = 1078; break;	/* stumaxb --> ldumaxb.  */
   19018     case 1139: value = 1079; break;	/* stumaxh --> ldumaxh.  */
   19019     case 1140: value = 1080; break;	/* stumax --> ldumax.  */
   19020     case 1141: value = 1082; break;	/* stumaxlb --> ldumaxlb.  */
   19021     case 1142: value = 1085; break;	/* stumaxlh --> ldumaxlh.  */
   19022     case 1143: value = 1088; break;	/* stumaxl --> ldumaxl.  */
   19023     case 1144: value = 1090; break;	/* stuminb --> lduminb.  */
   19024     case 1145: value = 1091; break;	/* stuminh --> lduminh.  */
   19025     case 1146: value = 1092; break;	/* stumin --> ldumin.  */
   19026     case 1147: value = 1094; break;	/* stuminlb --> lduminlb.  */
   19027     case 1148: value = 1097; break;	/* stuminlh --> lduminlh.  */
   19028     case 1149: value = 1100; break;	/* stuminl --> lduminl.  */
   19029     case 1151: value = 1150; break;	/* mov --> movn.  */
   19030     case 1153: value = 1152; break;	/* mov --> movz.  */
   19031     case 1191: value = 1190; break;	/* autibsp --> autibz.  */
   19032     case 1190: value = 1189; break;	/* autibz --> autiasp.  */
   19033     case 1189: value = 1188; break;	/* autiasp --> autiaz.  */
   19034     case 1188: value = 1187; break;	/* autiaz --> pacibsp.  */
   19035     case 1187: value = 1186; break;	/* pacibsp --> pacibz.  */
   19036     case 1186: value = 1185; break;	/* pacibz --> paciasp.  */
   19037     case 1185: value = 1184; break;	/* paciasp --> paciaz.  */
   19038     case 1184: value = 1171; break;	/* paciaz --> psb.  */
   19039     case 1171: value = 1170; break;	/* psb --> esb.  */
   19040     case 1170: value = 1169; break;	/* esb --> autib1716.  */
   19041     case 1169: value = 1168; break;	/* autib1716 --> autia1716.  */
   19042     case 1168: value = 1167; break;	/* autia1716 --> pacib1716.  */
   19043     case 1167: value = 1166; break;	/* pacib1716 --> pacia1716.  */
   19044     case 1166: value = 1165; break;	/* pacia1716 --> xpaclri.  */
   19045     case 1165: value = 1164; break;	/* xpaclri --> sevl.  */
   19046     case 1164: value = 1163; break;	/* sevl --> sev.  */
   19047     case 1163: value = 1162; break;	/* sev --> wfi.  */
   19048     case 1162: value = 1161; break;	/* wfi --> wfe.  */
   19049     case 1161: value = 1160; break;	/* wfe --> yield.  */
   19050     case 1160: value = 1159; break;	/* yield --> nop.  */
   19051     case 1159: value = 1158; break;	/* nop --> hint.  */
   19052     case 1180: value = 1179; break;	/* tlbi --> ic.  */
   19053     case 1179: value = 1178; break;	/* ic --> dc.  */
   19054     case 1178: value = 1177; break;	/* dc --> at.  */
   19055     case 1177: value = 1176; break;	/* at --> sys.  */
   19056     case 1973: value = 1239; break;	/* bic --> and.  */
   19057     case 1222: value = 1241; break;	/* mov --> and.  */
   19058     case 1226: value = 1242; break;	/* movs --> ands.  */
   19059     case 1974: value = 1277; break;	/* cmple --> cmpge.  */
   19060     case 1977: value = 1280; break;	/* cmplt --> cmpgt.  */
   19061     case 1975: value = 1282; break;	/* cmplo --> cmphi.  */
   19062     case 1976: value = 1285; break;	/* cmpls --> cmphs.  */
   19063     case 1219: value = 1307; break;	/* mov --> cpy.  */
   19064     case 1221: value = 1308; break;	/* mov --> cpy.  */
   19065     case 1984: value = 1224; break;	/* fmov --> mov.  */
   19066     case 1224: value = 1309; break;	/* mov --> cpy.  */
   19067     case 1214: value = 1321; break;	/* mov --> dup.  */
   19068     case 1216: value = 1213; break;	/* mov --> mov.  */
   19069     case 1213: value = 1322; break;	/* mov --> dup.  */
   19070     case 1983: value = 1218; break;	/* fmov --> mov.  */
   19071     case 1218: value = 1323; break;	/* mov --> dup.  */
   19072     case 1217: value = 1324; break;	/* mov --> dupm.  */
   19073     case 1978: value = 1326; break;	/* eon --> eor.  */
   19074     case 1227: value = 1328; break;	/* not --> eor.  */
   19075     case 1228: value = 1329; break;	/* nots --> eors.  */
   19076     case 1979: value = 1334; break;	/* facle --> facge.  */
   19077     case 1980: value = 1335; break;	/* faclt --> facgt.  */
   19078     case 1981: value = 1348; break;	/* fcmle --> fcmge.  */
   19079     case 1982: value = 1350; break;	/* fcmlt --> fcmgt.  */
   19080     case 1211: value = 1356; break;	/* fmov --> fcpy.  */
   19081     case 1210: value = 1379; break;	/* fmov --> fdup.  */
   19082     case 1212: value = 1694; break;	/* mov --> orr.  */
   19083     case 1985: value = 1695; break;	/* orn --> orr.  */
   19084     case 1215: value = 1697; break;	/* mov --> orr.  */
   19085     case 1225: value = 1698; break;	/* movs --> orrs.  */
   19086     case 1220: value = 1760; break;	/* mov --> sel.  */
   19087     case 1223: value = 1761; break;	/* mov --> sel.  */
   19088     default: return NULL;
   19089     }
   19090 
   19091   return aarch64_opcode_table + value;
   19092 }
   19093 
   19094 int
   19095 aarch64_extract_operand (const aarch64_operand *self,
   19096 			   aarch64_opnd_info *info,
   19097 			   aarch64_insn code, const aarch64_inst *inst)
   19098 {
   19099   /* Use the index as the key.  */
   19100   int key = self - aarch64_operands;
   19101   switch (key)
   19102     {
   19103     case 1:
   19104     case 2:
   19105     case 3:
   19106     case 4:
   19107     case 5:
   19108     case 6:
   19109     case 7:
   19110     case 9:
   19111     case 10:
   19112     case 11:
   19113     case 15:
   19114     case 16:
   19115     case 17:
   19116     case 18:
   19117     case 20:
   19118     case 21:
   19119     case 22:
   19120     case 23:
   19121     case 24:
   19122     case 25:
   19123     case 26:
   19124     case 27:
   19125     case 28:
   19126     case 147:
   19127     case 148:
   19128     case 149:
   19129     case 150:
   19130     case 151:
   19131     case 152:
   19132     case 153:
   19133     case 154:
   19134     case 155:
   19135     case 156:
   19136     case 169:
   19137     case 170:
   19138     case 171:
   19139     case 172:
   19140     case 173:
   19141     case 174:
   19142     case 175:
   19143     case 176:
   19144     case 177:
   19145     case 181:
   19146     case 184:
   19147       return aarch64_ext_regno (self, info, code, inst);
   19148     case 8:
   19149       return aarch64_ext_regrt_sysins (self, info, code, inst);
   19150     case 12:
   19151       return aarch64_ext_regno_pair (self, info, code, inst);
   19152     case 13:
   19153       return aarch64_ext_reg_extended (self, info, code, inst);
   19154     case 14:
   19155       return aarch64_ext_reg_shifted (self, info, code, inst);
   19156     case 19:
   19157       return aarch64_ext_ft (self, info, code, inst);
   19158     case 29:
   19159     case 30:
   19160     case 31:
   19161       return aarch64_ext_reglane (self, info, code, inst);
   19162     case 32:
   19163       return aarch64_ext_reglist (self, info, code, inst);
   19164     case 33:
   19165       return aarch64_ext_ldst_reglist (self, info, code, inst);
   19166     case 34:
   19167       return aarch64_ext_ldst_reglist_r (self, info, code, inst);
   19168     case 35:
   19169       return aarch64_ext_ldst_elemlist (self, info, code, inst);
   19170     case 36:
   19171     case 37:
   19172     case 38:
   19173     case 48:
   19174     case 49:
   19175     case 50:
   19176     case 51:
   19177     case 52:
   19178     case 53:
   19179     case 54:
   19180     case 55:
   19181     case 56:
   19182     case 57:
   19183     case 58:
   19184     case 59:
   19185     case 60:
   19186     case 71:
   19187     case 72:
   19188     case 73:
   19189     case 74:
   19190     case 75:
   19191     case 144:
   19192     case 146:
   19193     case 161:
   19194     case 162:
   19195     case 163:
   19196     case 164:
   19197     case 165:
   19198     case 166:
   19199     case 167:
   19200     case 168:
   19201       return aarch64_ext_imm (self, info, code, inst);
   19202     case 39:
   19203     case 40:
   19204       return aarch64_ext_advsimd_imm_shift (self, info, code, inst);
   19205     case 41:
   19206     case 42:
   19207     case 43:
   19208       return aarch64_ext_advsimd_imm_modified (self, info, code, inst);
   19209     case 44:
   19210       return aarch64_ext_shll_imm (self, info, code, inst);
   19211     case 47:
   19212     case 135:
   19213       return aarch64_ext_fpimm (self, info, code, inst);
   19214     case 61:
   19215     case 142:
   19216       return aarch64_ext_limm (self, info, code, inst);
   19217     case 62:
   19218       return aarch64_ext_aimm (self, info, code, inst);
   19219     case 63:
   19220       return aarch64_ext_imm_half (self, info, code, inst);
   19221     case 64:
   19222       return aarch64_ext_fbits (self, info, code, inst);
   19223     case 66:
   19224     case 67:
   19225     case 140:
   19226       return aarch64_ext_imm_rotate2 (self, info, code, inst);
   19227     case 68:
   19228     case 139:
   19229       return aarch64_ext_imm_rotate1 (self, info, code, inst);
   19230     case 69:
   19231     case 70:
   19232       return aarch64_ext_cond (self, info, code, inst);
   19233     case 76:
   19234     case 83:
   19235       return aarch64_ext_addr_simple (self, info, code, inst);
   19236     case 77:
   19237       return aarch64_ext_addr_regoff (self, info, code, inst);
   19238     case 78:
   19239     case 79:
   19240     case 80:
   19241       return aarch64_ext_addr_simm (self, info, code, inst);
   19242     case 81:
   19243       return aarch64_ext_addr_simm10 (self, info, code, inst);
   19244     case 82:
   19245       return aarch64_ext_addr_uimm12 (self, info, code, inst);
   19246     case 84:
   19247       return aarch64_ext_simd_addr_post (self, info, code, inst);
   19248     case 85:
   19249       return aarch64_ext_sysreg (self, info, code, inst);
   19250     case 86:
   19251       return aarch64_ext_pstatefield (self, info, code, inst);
   19252     case 87:
   19253     case 88:
   19254     case 89:
   19255     case 90:
   19256       return aarch64_ext_sysins_op (self, info, code, inst);
   19257     case 91:
   19258     case 92:
   19259       return aarch64_ext_barrier (self, info, code, inst);
   19260     case 93:
   19261       return aarch64_ext_prfop (self, info, code, inst);
   19262     case 94:
   19263       return aarch64_ext_hint (self, info, code, inst);
   19264     case 95:
   19265       return aarch64_ext_sve_addr_ri_s4 (self, info, code, inst);
   19266     case 96:
   19267     case 97:
   19268     case 98:
   19269     case 99:
   19270       return aarch64_ext_sve_addr_ri_s4xvl (self, info, code, inst);
   19271     case 100:
   19272       return aarch64_ext_sve_addr_ri_s6xvl (self, info, code, inst);
   19273     case 101:
   19274       return aarch64_ext_sve_addr_ri_s9xvl (self, info, code, inst);
   19275     case 102:
   19276     case 103:
   19277     case 104:
   19278     case 105:
   19279       return aarch64_ext_sve_addr_ri_u6 (self, info, code, inst);
   19280     case 106:
   19281     case 107:
   19282     case 108:
   19283     case 109:
   19284     case 110:
   19285     case 111:
   19286     case 112:
   19287     case 113:
   19288     case 114:
   19289     case 115:
   19290     case 116:
   19291     case 117:
   19292       return aarch64_ext_sve_addr_rr_lsl (self, info, code, inst);
   19293     case 118:
   19294     case 119:
   19295     case 120:
   19296     case 121:
   19297     case 122:
   19298     case 123:
   19299     case 124:
   19300     case 125:
   19301       return aarch64_ext_sve_addr_rz_xtw (self, info, code, inst);
   19302     case 126:
   19303     case 127:
   19304     case 128:
   19305     case 129:
   19306       return aarch64_ext_sve_addr_zi_u5 (self, info, code, inst);
   19307     case 130:
   19308       return aarch64_ext_sve_addr_zz_lsl (self, info, code, inst);
   19309     case 131:
   19310       return aarch64_ext_sve_addr_zz_sxtw (self, info, code, inst);
   19311     case 132:
   19312       return aarch64_ext_sve_addr_zz_uxtw (self, info, code, inst);
   19313     case 133:
   19314       return aarch64_ext_sve_aimm (self, info, code, inst);
   19315     case 134:
   19316       return aarch64_ext_sve_asimm (self, info, code, inst);
   19317     case 136:
   19318       return aarch64_ext_sve_float_half_one (self, info, code, inst);
   19319     case 137:
   19320       return aarch64_ext_sve_float_half_two (self, info, code, inst);
   19321     case 138:
   19322       return aarch64_ext_sve_float_zero_one (self, info, code, inst);
   19323     case 141:
   19324       return aarch64_ext_inv_limm (self, info, code, inst);
   19325     case 143:
   19326       return aarch64_ext_sve_limm_mov (self, info, code, inst);
   19327     case 145:
   19328       return aarch64_ext_sve_scale (self, info, code, inst);
   19329     case 157:
   19330     case 158:
   19331       return aarch64_ext_sve_shlimm (self, info, code, inst);
   19332     case 159:
   19333     case 160:
   19334       return aarch64_ext_sve_shrimm (self, info, code, inst);
   19335     case 178:
   19336     case 179:
   19337     case 180:
   19338       return aarch64_ext_sve_quad_index (self, info, code, inst);
   19339     case 182:
   19340       return aarch64_ext_sve_index (self, info, code, inst);
   19341     case 183:
   19342     case 185:
   19343       return aarch64_ext_sve_reglist (self, info, code, inst);
   19344     default: assert (0); abort ();
   19345     }
   19346 }
   19347