opcodes/aarch64-dis-2.c

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