opcodes/aarch64-dis-2.c

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