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 2377;
2372                                                     }
2373                                                   else
2374                                                     {
2375                                                       /* 33222222222211111111110000000000
2376                                                          10987654321098765432109876543210
2377                                                          10011001000xxxxxxxxx00xxxxxxxxxx
2378                                                          stlur.  */
2379                                                       return 2385;
2380                                                     }
2381                                                 }
2382                                               else
2383                                                 {
2384                                                   if (((word >> 31) & 0x1) == 0)
2385                                                     {
2386                                                       /* 33222222222211111111110000000000
2387                                                          10987654321098765432109876543210
2388                                                          01011001000xxxxxxxxx00xxxxxxxxxx
2389                                                          stlurh.  */
2390                                                       return 2381;
2391                                                     }
2392                                                   else
2393                                                     {
2394                                                       /* 33222222222211111111110000000000
2395                                                          10987654321098765432109876543210
2396                                                          11011001000xxxxxxxxx00xxxxxxxxxx
2397                                                          stlur.  */
2398                                                       return 2388;
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 2378;
2479                                                     }
2480                                                   else
2481                                                     {
2482                                                       /* 33222222222211111111110000000000
2483                                                          10987654321098765432109876543210
2484                                                          10011001010xxxxxxxxx00xxxxxxxxxx
2485                                                          ldapur.  */
2486                                                       return 2386;
2487                                                     }
2488                                                 }
2489                                               else
2490                                                 {
2491                                                   if (((word >> 31) & 0x1) == 0)
2492                                                     {
2493                                                       /* 33222222222211111111110000000000
2494                                                          10987654321098765432109876543210
2495                                                          01011001010xxxxxxxxx00xxxxxxxxxx
2496                                                          ldapurh.  */
2497                                                       return 2382;
2498                                                     }
2499                                                   else
2500                                                     {
2501                                                       /* 33222222222211111111110000000000
2502                                                          10987654321098765432109876543210
2503                                                          11011001010xxxxxxxxx00xxxxxxxxxx
2504                                                          ldapur.  */
2505                                                       return 2389;
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 2380;
2589                                                     }
2590                                                   else
2591                                                     {
2592                                                       /* 33222222222211111111110000000000
2593                                                          10987654321098765432109876543210
2594                                                          10011001100xxxxxxxxx00xxxxxxxxxx
2595                                                          ldapursw.  */
2596                                                       return 2387;
2597                                                     }
2598                                                 }
2599                                               else
2600                                                 {
2601                                                   /* 33222222222211111111110000000000
2602                                                      10987654321098765432109876543210
2603                                                      x1011001100xxxxxxxxx00xxxxxxxxxx
2604                                                      ldapursh.  */
2605                                                   return 2384;
2606                                                 }
2607                                             }
2608                                           else
2609                                             {
2610                                               if (((word >> 30) & 0x1) == 0)
2611                                                 {
2612                                                   /* 33222222222211111111110000000000
2613                                                      10987654321098765432109876543210
2614                                                      x0011001110xxxxxxxxx00xxxxxxxxxx
2615                                                      ldapursb.  */
2616                                                   return 2379;
2617                                                 }
2618                                               else
2619                                                 {
2620                                                   /* 33222222222211111111110000000000
2621                                                      10987654321098765432109876543210
2622                                                      x1011001110xxxxxxxxx00xxxxxxxxxx
2623                                                      ldapursh.  */
2624                                                   return 2383;
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 2375;
3111                                         }
3112                                       else
3113                                         {
3114                                           /* 33222222222211111111110000000000
3115                                              10987654321098765432109876543210
3116                                              xxx11010x00xxxxxx1xx10xxxxxxxxxx
3117                                              setf16.  */
3118                                           return 2376;
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 2374;
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 1275;
3803                                                                 }
3804                                                               else
3805                                                                 {
3806                                                                   /* 33222222222211111111110000000000
3807                                                                      10987654321098765432109876543210
3808                                                                      000001x0xx010000000xxxxxxxxxxxxx
3809                                                                      mul.  */
3810                                                                   return 1744;
3811                                                                 }
3812                                                             }
3813                                                           else
3814                                                             {
3815                                                               if (((word >> 20) & 0x1) == 0)
3816                                                                 {
3817                                                                   /* 33222222222211111111110000000000
3818                                                                      10987654321098765432109876543210
3819                                                                      000001x0xx001000000xxxxxxxxxxxxx
3820                                                                      smax.  */
3821                                                                   return 1823;
3822                                                                 }
3823                                                               else
3824                                                                 {
3825                                                                   /* 33222222222211111111110000000000
3826                                                                      10987654321098765432109876543210
3827                                                                      000001x0xx011000000xxxxxxxxxxxxx
3828                                                                      orr.  */
3829                                                                   return 1755;
3830                                                                 }
3831                                                             }
3832                                                         }
3833                                                       else
3834                                                         {
3835                                                           if (((word >> 19) & 0x1) == 0)
3836                                                             {
3837                                                               /* 33222222222211111111110000000000
3838                                                                  10987654321098765432109876543210
3839                                                                  000001x0xx0x0100000xxxxxxxxxxxxx
3840                                                                  sdiv.  */
3841                                                               return 1814;
3842                                                             }
3843                                                           else
3844                                                             {
3845                                                               /* 33222222222211111111110000000000
3846                                                                  10987654321098765432109876543210
3847                                                                  000001x0xx0x1100000xxxxxxxxxxxxx
3848                                                                  sabd.  */
3849                                                               return 1805;
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 1828;
3864                                                             }
3865                                                           else
3866                                                             {
3867                                                               if (((word >> 20) & 0x1) == 0)
3868                                                                 {
3869                                                                   /* 33222222222211111111110000000000
3870                                                                      10987654321098765432109876543210
3871                                                                      000001x0xx001010000xxxxxxxxxxxxx
3872                                                                      smin.  */
3873                                                                   return 1826;
3874                                                                 }
3875                                                               else
3876                                                                 {
3877                                                                   /* 33222222222211111111110000000000
3878                                                                      10987654321098765432109876543210
3879                                                                      000001x0xx011010000xxxxxxxxxxxxx
3880                                                                      and.  */
3881                                                                   return 1283;
3882                                                                 }
3883                                                             }
3884                                                         }
3885                                                       else
3886                                                         {
3887                                                           /* 33222222222211111111110000000000
3888                                                              10987654321098765432109876543210
3889                                                              000001x0xx0xx110000xxxxxxxxxxxxx
3890                                                              sdivr.  */
3891                                                           return 1815;
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 1944;
3908                                                             }
3909                                                           else
3910                                                             {
3911                                                               if (((word >> 20) & 0x1) == 0)
3912                                                                 {
3913                                                                   /* 33222222222211111111110000000000
3914                                                                      10987654321098765432109876543210
3915                                                                      000001x0xx001001000xxxxxxxxxxxxx
3916                                                                      umax.  */
3917                                                                   return 1972;
3918                                                                 }
3919                                                               else
3920                                                                 {
3921                                                                   /* 33222222222211111111110000000000
3922                                                                      10987654321098765432109876543210
3923                                                                      000001x0xx011001000xxxxxxxxxxxxx
3924                                                                      eor.  */
3925                                                                   return 1370;
3926                                                                 }
3927                                                             }
3928                                                         }
3929                                                       else
3930                                                         {
3931                                                           if (((word >> 19) & 0x1) == 0)
3932                                                             {
3933                                                               /* 33222222222211111111110000000000
3934                                                                  10987654321098765432109876543210
3935                                                                  000001x0xx0x0101000xxxxxxxxxxxxx
3936                                                                  udiv.  */
3937                                                               return 1966;
3938                                                             }
3939                                                           else
3940                                                             {
3941                                                               /* 33222222222211111111110000000000
3942                                                                  10987654321098765432109876543210
3943                                                                  000001x0xx0x1101000xxxxxxxxxxxxx
3944                                                                  uabd.  */
3945                                                               return 1957;
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 1946;
3962                                                                 }
3963                                                               else
3964                                                                 {
3965                                                                   /* 33222222222211111111110000000000
3966                                                                      10987654321098765432109876543210
3967                                                                      000001x0xx010011000xxxxxxxxxxxxx
3968                                                                      umulh.  */
3969                                                                   return 1977;
3970                                                                 }
3971                                                             }
3972                                                           else
3973                                                             {
3974                                                               if (((word >> 20) & 0x1) == 0)
3975                                                                 {
3976                                                                   /* 33222222222211111111110000000000
3977                                                                      10987654321098765432109876543210
3978                                                                      000001x0xx001011000xxxxxxxxxxxxx
3979                                                                      umin.  */
3980                                                                   return 1975;
3981                                                                 }
3982                                                               else
3983                                                                 {
3984                                                                   /* 33222222222211111111110000000000
3985                                                                      10987654321098765432109876543210
3986                                                                      000001x0xx011011000xxxxxxxxxxxxx
3987                                                                      bic.  */
3988                                                                   return 1295;
3989                                                                 }
3990                                                             }
3991                                                         }
3992                                                       else
3993                                                         {
3994                                                           /* 33222222222211111111110000000000
3995                                                              10987654321098765432109876543210
3996                                                              000001x0xx0xx111000xxxxxxxxxxxxx
3997                                                              udivr.  */
3998                                                           return 1967;
3999                                                         }
4000                                                     }
4001                                                 }
4002                                             }
4003                                           else
4004                                             {
4005                                               if (((word >> 23) & 0x1) == 0)
4006                                                 {
4007                                                   /* 33222222222211111111110000000000
4008                                                      10987654321098765432109876543210
4009                                                      100001x00x0xxxxx000xxxxxxxxxxxxx
4010                                                      ld1sb.  */
4011                                                   return 1557;
4012                                                 }
4013                                               else
4014                                                 {
4015                                                   /* 33222222222211111111110000000000
4016                                                      10987654321098765432109876543210
4017                                                      100001x01x0xxxxx000xxxxxxxxxxxxx
4018                                                      ld1sh.  */
4019                                                   return 1568;
4020                                                 }
4021                                             }
4022                                         }
4023                                       else
4024                                         {
4025                                           if (((word >> 31) & 0x1) == 0)
4026                                             {
4027                                               if (((word >> 12) & 0x1) == 0)
4028                                                 {
4029                                                   if (((word >> 10) & 0x1) == 0)
4030                                                     {
4031                                                       if (((word >> 11) & 0x1) == 0)
4032                                                         {
4033                                                           /* 33222222222211111111110000000000
4034                                                              10987654321098765432109876543210
4035                                                              010001x0xx0xxxxx000000xxxxxxxxxx
4036                                                              sdot.  */
4037                                                           return 1816;
4038                                                         }
4039                                                       else
4040                                                         {
4041                                                           /* 33222222222211111111110000000000
4042                                                              10987654321098765432109876543210
4043                                                              010001x0xx0xxxxx000010xxxxxxxxxx
4044                                                              sqdmlalbt.  */
4045                                                           return 2166;
4046                                                         }
4047                                                     }
4048                                                   else
4049                                                     {
4050                                                       if (((word >> 11) & 0x1) == 0)
4051                                                         {
4052                                                           /* 33222222222211111111110000000000
4053                                                              10987654321098765432109876543210
4054                                                              010001x0xx0xxxxx000001xxxxxxxxxx
4055                                                              udot.  */
4056                                                           return 1968;
4057                                                         }
4058                                                       else
4059                                                         {
4060                                                           /* 33222222222211111111110000000000
4061                                                              10987654321098765432109876543210
4062                                                              010001x0xx0xxxxx000011xxxxxxxxxx
4063                                                              sqdmlslbt.  */
4064                                                           return 2173;
4065                                                         }
4066                                                     }
4067                                                 }
4068                                               else
4069                                                 {
4070                                                   /* 33222222222211111111110000000000
4071                                                      10987654321098765432109876543210
4072                                                      010001x0xx0xxxxx0001xxxxxxxxxxxx
4073                                                      cdot.  */
4074                                                   return 2055;
4075                                                 }
4076                                             }
4077                                           else
4078                                             {
4079                                               if (((word >> 23) & 0x1) == 0)
4080                                                 {
4081                                                   /* 33222222222211111111110000000000
4082                                                      10987654321098765432109876543210
4083                                                      110001x00x0xxxxx000xxxxxxxxxxxxx
4084                                                      ld1sb.  */
4085                                                   return 1561;
4086                                                 }
4087                                               else
4088                                                 {
4089                                                   /* 33222222222211111111110000000000
4090                                                      10987654321098765432109876543210
4091                                                      110001x01x0xxxxx000xxxxxxxxxxxxx
4092                                                      ld1sh.  */
4093                                                   return 1572;
4094                                                 }
4095                                             }
4096                                         }
4097                                     }
4098                                   else
4099                                     {
4100                                       if (((word >> 30) & 0x1) == 0)
4101                                         {
4102                                           if (((word >> 31) & 0x1) == 0)
4103                                             {
4104                                               if (((word >> 10) & 0x1) == 0)
4105                                                 {
4106                                                   if (((word >> 11) & 0x1) == 0)
4107                                                     {
4108                                                       if (((word >> 12) & 0x1) == 0)
4109                                                         {
4110                                                           /* 33222222222211111111110000000000
4111                                                              10987654321098765432109876543210
4112                                                              000001x0xx1xxxxx000000xxxxxxxxxx
4113                                                              add.  */
4114                                                           return 1273;
4115                                                         }
4116                                                       else
4117                                                         {
4118                                                           /* 33222222222211111111110000000000
4119                                                              10987654321098765432109876543210
4120                                                              000001x0xx1xxxxx000100xxxxxxxxxx
4121                                                              sqadd.  */
4122                                                           return 1830;
4123                                                         }
4124                                                     }
4125                                                   else
4126                                                     {
4127                                                       /* 33222222222211111111110000000000
4128                                                          10987654321098765432109876543210
4129                                                          000001x0xx1xxxxx000x10xxxxxxxxxx
4130                                                          sqsub.  */
4131                                                       return 1860;
4132                                                     }
4133                                                 }
4134                                               else
4135                                                 {
4136                                                   if (((word >> 11) & 0x1) == 0)
4137                                                     {
4138                                                       if (((word >> 12) & 0x1) == 0)
4139                                                         {
4140                                                           /* 33222222222211111111110000000000
4141                                                              10987654321098765432109876543210
4142                                                              000001x0xx1xxxxx000001xxxxxxxxxx
4143                                                              sub.  */
4144                                                           return 1942;
4145                                                         }
4146                                                       else
4147                                                         {
4148                                                           /* 33222222222211111111110000000000
4149                                                              10987654321098765432109876543210
4150                                                              000001x0xx1xxxxx000101xxxxxxxxxx
4151                                                              uqadd.  */
4152                                                           return 1978;
4153                                                         }
4154                                                     }
4155                                                   else
4156                                                     {
4157                                                       /* 33222222222211111111110000000000
4158                                                          10987654321098765432109876543210
4159                                                          000001x0xx1xxxxx000x11xxxxxxxxxx
4160                                                          uqsub.  */
4161                                                       return 2008;
4162                                                     }
4163                                                 }
4164                                             }
4165                                           else
4166                                             {
4167                                               if (((word >> 23) & 0x1) == 0)
4168                                                 {
4169                                                   /* 33222222222211111111110000000000
4170                                                      10987654321098765432109876543210
4171                                                      100001x00x1xxxxx000xxxxxxxxxxxxx
4172                                                      prfb.  */
4173                                                   return 1763;
4174                                                 }
4175                                               else
4176                                                 {
4177                                                   /* 33222222222211111111110000000000
4178                                                      10987654321098765432109876543210
4179                                                      100001x01x1xxxxx000xxxxxxxxxxxxx
4180                                                      ld1sh.  */
4181                                                   return 1569;
4182                                                 }
4183                                             }
4184                                         }
4185                                       else
4186                                         {
4187                                           if (((word >> 23) & 0x1) == 0)
4188                                             {
4189                                               if (((word >> 31) & 0x1) == 0)
4190                                                 {
4191                                                   if (((word >> 10) & 0x1) == 0)
4192                                                     {
4193                                                       if (((word >> 11) & 0x1) == 0)
4194                                                         {
4195                                                           /* 33222222222211111111110000000000
4196                                                              10987654321098765432109876543210
4197                                                              010001x00x1xxxxx000x00xxxxxxxxxx
4198                                                              sqrdmlah.  */
4199                                                           return 2191;
4200                                                         }
4201                                                       else
4202                                                         {
4203                                                           /* 33222222222211111111110000000000
4204                                                              10987654321098765432109876543210
4205                                                              010001x00x1xxxxx000x10xxxxxxxxxx
4206                                                              mla.  */
4207                                                           return 2098;
4208                                                         }
4209                                                     }
4210                                                   else
4211                                                     {
4212                                                       if (((word >> 11) & 0x1) == 0)
4213                                                         {
4214                                                           /* 33222222222211111111110000000000
4215                                                              10987654321098765432109876543210
4216                                                              010001x00x1xxxxx000x01xxxxxxxxxx
4217                                                              sqrdmlsh.  */
4218                                                           return 2195;
4219                                                         }
4220                                                       else
4221                                                         {
4222                                                           /* 33222222222211111111110000000000
4223                                                              10987654321098765432109876543210
4224                                                              010001x00x1xxxxx000x11xxxxxxxxxx
4225                                                              mls.  */
4226                                                           return 2101;
4227                                                         }
4228                                                     }
4229                                                 }
4230                                               else
4231                                                 {
4232                                                   /* 33222222222211111111110000000000
4233                                                      10987654321098765432109876543210
4234                                                      110001x00x1xxxxx000xxxxxxxxxxxxx
4235                                                      prfb.  */
4236                                                   return 1764;
4237                                                 }
4238                                             }
4239                                           else
4240                                             {
4241                                               if (((word >> 31) & 0x1) == 0)
4242                                                 {
4243                                                   if (((word >> 10) & 0x1) == 0)
4244                                                     {
4245                                                       if (((word >> 11) & 0x1) == 0)
4246                                                         {
4247                                                           if (((word >> 12) & 0x1) == 0)
4248                                                             {
4249                                                               if (((word >> 22) & 0x1) == 0)
4250                                                                 {
4251                                                                   /* 33222222222211111111110000000000
4252                                                                      10987654321098765432109876543210
4253                                                                      010001x0101xxxxx000000xxxxxxxxxx
4254                                                                      sdot.  */
4255                                                                   return 1817;
4256                                                                 }
4257                                                               else
4258                                                                 {
4259                                                                   /* 33222222222211111111110000000000
4260                                                                      10987654321098765432109876543210
4261                                                                      010001x0111xxxxx000000xxxxxxxxxx
4262                                                                      sdot.  */
4263                                                                   return 1818;
4264                                                                 }
4265                                                             }
4266                                                           else
4267                                                             {
4268                                                               if (((word >> 22) & 0x1) == 0)
4269                                                                 {
4270                                                                   /* 33222222222211111111110000000000
4271                                                                      10987654321098765432109876543210
4272                                                                      010001x0101xxxxx000100xxxxxxxxxx
4273                                                                      sqrdmlah.  */
4274                                                                   return 2192;
4275                                                                 }
4276                                                               else
4277                                                                 {
4278                                                                   /* 33222222222211111111110000000000
4279                                                                      10987654321098765432109876543210
4280                                                                      010001x0111xxxxx000100xxxxxxxxxx
4281                                                                      sqrdmlah.  */
4282                                                                   return 2193;
4283                                                                 }
4284                                                             }
4285                                                         }
4286                                                       else
4287                                                         {
4288                                                           if (((word >> 22) & 0x1) == 0)
4289                                                             {
4290                                                               /* 33222222222211111111110000000000
4291                                                                  10987654321098765432109876543210
4292                                                                  010001x0101xxxxx000x10xxxxxxxxxx
4293                                                                  mla.  */
4294                                                               return 2099;
4295                                                             }
4296                                                           else
4297                                                             {
4298                                                               /* 33222222222211111111110000000000
4299                                                                  10987654321098765432109876543210
4300                                                                  010001x0111xxxxx000x10xxxxxxxxxx
4301                                                                  mla.  */
4302                                                               return 2100;
4303                                                             }
4304                                                         }
4305                                                     }
4306                                                   else
4307                                                     {
4308                                                       if (((word >> 11) & 0x1) == 0)
4309                                                         {
4310                                                           if (((word >> 12) & 0x1) == 0)
4311                                                             {
4312                                                               if (((word >> 22) & 0x1) == 0)
4313                                                                 {
4314                                                                   /* 33222222222211111111110000000000
4315                                                                      10987654321098765432109876543210
4316                                                                      010001x0101xxxxx000001xxxxxxxxxx
4317                                                                      udot.  */
4318                                                                   return 1969;
4319                                                                 }
4320                                                               else
4321                                                                 {
4322                                                                   /* 33222222222211111111110000000000
4323                                                                      10987654321098765432109876543210
4324                                                                      010001x0111xxxxx000001xxxxxxxxxx
4325                                                                      udot.  */
4326                                                                   return 1970;
4327                                                                 }
4328                                                             }
4329                                                           else
4330                                                             {
4331                                                               if (((word >> 22) & 0x1) == 0)
4332                                                                 {
4333                                                                   /* 33222222222211111111110000000000
4334                                                                      10987654321098765432109876543210
4335                                                                      010001x0101xxxxx000101xxxxxxxxxx
4336                                                                      sqrdmlsh.  */
4337                                                                   return 2196;
4338                                                                 }
4339                                                               else
4340                                                                 {
4341                                                                   /* 33222222222211111111110000000000
4342                                                                      10987654321098765432109876543210
4343                                                                      010001x0111xxxxx000101xxxxxxxxxx
4344                                                                      sqrdmlsh.  */
4345                                                                   return 2197;
4346                                                                 }
4347                                                             }
4348                                                         }
4349                                                       else
4350                                                         {
4351                                                           if (((word >> 22) & 0x1) == 0)
4352                                                             {
4353                                                               /* 33222222222211111111110000000000
4354                                                                  10987654321098765432109876543210
4355                                                                  010001x0101xxxxx000x11xxxxxxxxxx
4356                                                                  mls.  */
4357                                                               return 2102;
4358                                                             }
4359                                                           else
4360                                                             {
4361                                                               /* 33222222222211111111110000000000
4362                                                                  10987654321098765432109876543210
4363                                                                  010001x0111xxxxx000x11xxxxxxxxxx
4364                                                                  mls.  */
4365                                                               return 2103;
4366                                                             }
4367                                                         }
4368                                                     }
4369                                                 }
4370                                               else
4371                                                 {
4372                                                   /* 33222222222211111111110000000000
4373                                                      10987654321098765432109876543210
4374                                                      110001x01x1xxxxx000xxxxxxxxxxxxx
4375                                                      ld1sh.  */
4376                                                   return 1573;
4377                                                 }
4378                                             }
4379                                         }
4380                                     }
4381                                 }
4382                               else
4383                                 {
4384                                   if (((word >> 31) & 0x1) == 0)
4385                                     {
4386                                       if (((word >> 21) & 0x1) == 0)
4387                                         {
4388                                           if (((word >> 16) & 0x1) == 0)
4389                                             {
4390                                               if (((word >> 17) & 0x1) == 0)
4391                                                 {
4392                                                   if (((word >> 18) & 0x1) == 0)
4393                                                     {
4394                                                       if (((word >> 19) & 0x1) == 0)
4395                                                         {
4396                                                           if (((word >> 20) & 0x1) == 0)
4397                                                             {
4398                                                               /* 33222222222211111111110000000000
4399                                                                  10987654321098765432109876543210
4400                                                                  0x0001x0xx000000100xxxxxxxxxxxxx
4401                                                                  asr.  */
4402                                                               return 1291;
4403                                                             }
4404                                                           else
4405                                                             {
4406                                                               if (((word >> 30) & 0x1) == 0)
4407                                                                 {
4408                                                                   /* 33222222222211111111110000000000
4409                                                                      10987654321098765432109876543210
4410                                                                      000001x0xx010000100xxxxxxxxxxxxx
4411                                                                      asr.  */
4412                                                                   return 1289;
4413                                                                 }
4414                                                               else
4415                                                                 {
4416                                                                   /* 33222222222211111111110000000000
4417                                                                      10987654321098765432109876543210
4418                                                                      010001x0xx010000100xxxxxxxxxxxxx
4419                                                                      shadd.  */
4420                                                                   return 2132;
4421                                                                 }
4422                                                             }
4423                                                         }
4424                                                       else
4425                                                         {
4426                                                           if (((word >> 20) & 0x1) == 0)
4427                                                             {
4428                                                               /* 33222222222211111111110000000000
4429                                                                  10987654321098765432109876543210
4430                                                                  0x0001x0xx001000100xxxxxxxxxxxxx
4431                                                                  sqshl.  */
4432                                                               return 2210;
4433                                                             }
4434                                                           else
4435                                                             {
4436                                                               if (((word >> 30) & 0x1) == 0)
4437                                                                 {
4438                                                                   /* 33222222222211111111110000000000
4439                                                                      10987654321098765432109876543210
4440                                                                      000001x0xx011000100xxxxxxxxxxxxx
4441                                                                      asr.  */
4442                                                                   return 1290;
4443                                                                 }
4444                                                               else
4445                                                                 {
4446                                                                   /* 33222222222211111111110000000000
4447                                                                      10987654321098765432109876543210
4448                                                                      010001x0xx011000100xxxxxxxxxxxxx
4449                                                                      sqadd.  */
4450                                                                   return 2161;
4451                                                                 }
4452                                                             }
4453                                                         }
4454                                                     }
4455                                                   else
4456                                                     {
4457                                                       if (((word >> 19) & 0x1) == 0)
4458                                                         {
4459                                                           if (((word >> 20) & 0x1) == 0)
4460                                                             {
4461                                                               /* 33222222222211111111110000000000
4462                                                                  10987654321098765432109876543210
4463                                                                  0x0001x0xx000100100xxxxxxxxxxxxx
4464                                                                  asrd.  */
4465                                                               return 1292;
4466                                                             }
4467                                                           else
4468                                                             {
4469                                                               if (((word >> 30) & 0x1) == 0)
4470                                                                 {
4471                                                                   /* 33222222222211111111110000000000
4472                                                                      10987654321098765432109876543210
4473                                                                      000001x0xx010100100xxxxxxxxxxxxx
4474                                                                      asrr.  */
4475                                                                   return 1293;
4476                                                                 }
4477                                                               else
4478                                                                 {
4479                                                                   /* 33222222222211111111110000000000
4480                                                                      10987654321098765432109876543210
4481                                                                      010001x0xx010100100xxxxxxxxxxxxx
4482                                                                      srhadd.  */
4483                                                                   return 2223;
4484                                                                 }
4485                                                             }
4486                                                         }
4487                                                       else
4488                                                         {
4489                                                           if (((word >> 20) & 0x1) == 0)
4490                                                             {
4491                                                               if (((word >> 30) & 0x1) == 0)
4492                                                                 {
4493                                                                   /* 33222222222211111111110000000000
4494                                                                      10987654321098765432109876543210
4495                                                                      000001x0xx001100100xxxxxxxxxxxxx
4496                                                                      srshr.  */
4497                                                                   return 2227;
4498                                                                 }
4499                                                               else
4500                                                                 {
4501                                                                   /* 33222222222211111111110000000000
4502                                                                      10987654321098765432109876543210
4503                                                                      010001x0xx001100100xxxxxxxxxxxxx
4504                                                                      sqshlr.  */
4505                                                                   return 2211;
4506                                                                 }
4507                                                             }
4508                                                           else
4509                                                             {
4510                                                               /* 33222222222211111111110000000000
4511                                                                  10987654321098765432109876543210
4512                                                                  0x0001x0xx011100100xxxxxxxxxxxxx
4513                                                                  suqadd.  */
4514                                                               return 2247;
4515                                                             }
4516                                                         }
4517                                                     }
4518                                                 }
4519                                               else
4520                                                 {
4521                                                   if (((word >> 18) & 0x1) == 0)
4522                                                     {
4523                                                       if (((word >> 19) & 0x1) == 0)
4524                                                         {
4525                                                           if (((word >> 20) & 0x1) == 0)
4526                                                             {
4527                                                               /* 33222222222211111111110000000000
4528                                                                  10987654321098765432109876543210
4529                                                                  0x0001x0xx000010100xxxxxxxxxxxxx
4530                                                                  srshl.  */
4531                                                               return 2225;
4532                                                             }
4533                                                           else
4534                                                             {
4535                                                               /* 33222222222211111111110000000000
4536                                                                  10987654321098765432109876543210
4537                                                                  0x0001x0xx010010100xxxxxxxxxxxxx
4538                                                                  shsub.  */
4539                                                               return 2135;
4540                                                             }
4541                                                         }
4542                                                       else
4543                                                         {
4544                                                           if (((word >> 20) & 0x1) == 0)
4545                                                             {
4546                                                               /* 33222222222211111111110000000000
4547                                                                  10987654321098765432109876543210
4548                                                                  0x0001x0xx001010100xxxxxxxxxxxxx
4549                                                                  sqrshl.  */
4550                                                               return 2203;
4551                                                             }
4552                                                           else
4553                                                             {
4554                                                               /* 33222222222211111111110000000000
4555                                                                  10987654321098765432109876543210
4556                                                                  0x0001x0xx011010100xxxxxxxxxxxxx
4557                                                                  sqsub.  */
4558                                                               return 2217;
4559                                                             }
4560                                                         }
4561                                                     }
4562                                                   else
4563                                                     {
4564                                                       if (((word >> 19) & 0x1) == 0)
4565                                                         {
4566                                                           if (((word >> 20) & 0x1) == 0)
4567                                                             {
4568                                                               if (((word >> 30) & 0x1) == 0)
4569                                                                 {
4570                                                                   /* 33222222222211111111110000000000
4571                                                                      10987654321098765432109876543210
4572                                                                      000001x0xx000110100xxxxxxxxxxxxx
4573                                                                      sqshl.  */
4574                                                                   return 2209;
4575                                                                 }
4576                                                               else
4577                                                                 {
4578                                                                   /* 33222222222211111111110000000000
4579                                                                      10987654321098765432109876543210
4580                                                                      010001x0xx000110100xxxxxxxxxxxxx
4581                                                                      srshlr.  */
4582                                                                   return 2226;
4583                                                                 }
4584                                                             }
4585                                                           else
4586                                                             {
4587                                                               /* 33222222222211111111110000000000
4588                                                                  10987654321098765432109876543210
4589                                                                  0x0001x0xx010110100xxxxxxxxxxxxx
4590                                                                  shsubr.  */
4591                                                               return 2136;
4592                                                             }
4593                                                         }
4594                                                       else
4595                                                         {
4596                                                           if (((word >> 20) & 0x1) == 0)
4597                                                             {
4598                                                               /* 33222222222211111111110000000000
4599                                                                  10987654321098765432109876543210
4600                                                                  0x0001x0xx001110100xxxxxxxxxxxxx
4601                                                                  sqrshlr.  */
4602                                                               return 2204;
4603                                                             }
4604                                                           else
4605                                                             {
4606                                                               /* 33222222222211111111110000000000
4607                                                                  10987654321098765432109876543210
4608                                                                  0x0001x0xx011110100xxxxxxxxxxxxx
4609                                                                  sqsubr.  */
4610                                                               return 2218;
4611                                                             }
4612                                                         }
4613                                                     }
4614                                                 }
4615                                             }
4616                                           else
4617                                             {
4618                                               if (((word >> 17) & 0x1) == 0)
4619                                                 {
4620                                                   if (((word >> 18) & 0x1) == 0)
4621                                                     {
4622                                                       if (((word >> 19) & 0x1) == 0)
4623                                                         {
4624                                                           if (((word >> 20) & 0x1) == 0)
4625                                                             {
4626                                                               /* 33222222222211111111110000000000
4627                                                                  10987654321098765432109876543210
4628                                                                  0x0001x0xx000001100xxxxxxxxxxxxx
4629                                                                  lsr.  */
4630                                                               return 1735;
4631                                                             }
4632                                                           else
4633                                                             {
4634                                                               if (((word >> 30) & 0x1) == 0)
4635                                                                 {
4636                                                                   /* 33222222222211111111110000000000
4637                                                                      10987654321098765432109876543210
4638                                                                      000001x0xx010001100xxxxxxxxxxxxx
4639                                                                      lsr.  */
4640                                                                   return 1733;
4641                                                                 }
4642                                                               else
4643                                                                 {
4644                                                                   /* 33222222222211111111110000000000
4645                                                                      10987654321098765432109876543210
4646                                                                      010001x0xx010001100xxxxxxxxxxxxx
4647                                                                      uhadd.  */
4648                                                                   return 2260;
4649                                                                 }
4650                                                             }
4651                                                         }
4652                                                       else
4653                                                         {
4654                                                           if (((word >> 20) & 0x1) == 0)
4655                                                             {
4656                                                               /* 33222222222211111111110000000000
4657                                                                  10987654321098765432109876543210
4658                                                                  0x0001x0xx001001100xxxxxxxxxxxxx
4659                                                                  uqshl.  */
4660                                                               return 2290;
4661                                                             }
4662                                                           else
4663                                                             {
4664                                                               if (((word >> 30) & 0x1) == 0)
4665                                                                 {
4666                                                                   /* 33222222222211111111110000000000
4667                                                                      10987654321098765432109876543210
4668                                                                      000001x0xx011001100xxxxxxxxxxxxx
4669                                                                      lsr.  */
4670                                                                   return 1734;
4671                                                                 }
4672                                                               else
4673                                                                 {
4674                                                                   /* 33222222222211111111110000000000
4675                                                                      10987654321098765432109876543210
4676                                                                      010001x0xx011001100xxxxxxxxxxxxx
4677                                                                      uqadd.  */
4678                                                                   return 2284;
4679                                                                 }
4680                                                             }
4681                                                         }
4682                                                     }
4683                                                   else
4684                                                     {
4685                                                       if (((word >> 19) & 0x1) == 0)
4686                                                         {
4687                                                           if (((word >> 30) & 0x1) == 0)
4688                                                             {
4689                                                               /* 33222222222211111111110000000000
4690                                                                  10987654321098765432109876543210
4691                                                                  000001x0xx0x0101100xxxxxxxxxxxxx
4692                                                                  lsrr.  */
4693                                                               return 1736;
4694                                                             }
4695                                                           else
4696                                                             {
4697                                                               /* 33222222222211111111110000000000
4698                                                                  10987654321098765432109876543210
4699                                                                  010001x0xx0x0101100xxxxxxxxxxxxx
4700                                                                  urhadd.  */
4701                                                               return 2299;
4702                                                             }
4703                                                         }
4704                                                       else
4705                                                         {
4706                                                           if (((word >> 20) & 0x1) == 0)
4707                                                             {
4708                                                               if (((word >> 30) & 0x1) == 0)
4709                                                                 {
4710                                                                   /* 33222222222211111111110000000000
4711                                                                      10987654321098765432109876543210
4712                                                                      000001x0xx001101100xxxxxxxxxxxxx
4713                                                                      urshr.  */
4714                                                                   return 2302;
4715                                                                 }
4716                                                               else
4717                                                                 {
4718                                                                   /* 33222222222211111111110000000000
4719                                                                      10987654321098765432109876543210
4720                                                                      010001x0xx001101100xxxxxxxxxxxxx
4721                                                                      uqshlr.  */
4722                                                                   return 2291;
4723                                                                 }
4724                                                             }
4725                                                           else
4726                                                             {
4727                                                               /* 33222222222211111111110000000000
4728                                                                  10987654321098765432109876543210
4729                                                                  0x0001x0xx011101100xxxxxxxxxxxxx
4730                                                                  usqadd.  */
4731                                                               return 2307;
4732                                                             }
4733                                                         }
4734                                                     }
4735                                                 }
4736                                               else
4737                                                 {
4738                                                   if (((word >> 18) & 0x1) == 0)
4739                                                     {
4740                                                       if (((word >> 19) & 0x1) == 0)
4741                                                         {
4742                                                           if (((word >> 20) & 0x1) == 0)
4743                                                             {
4744                                                               if (((word >> 30) & 0x1) == 0)
4745                                                                 {
4746                                                                   /* 33222222222211111111110000000000
4747                                                                      10987654321098765432109876543210
4748                                                                      000001x0xx000011100xxxxxxxxxxxxx
4749                                                                      lsl.  */
4750                                                                   return 1729;
4751                                                                 }
4752                                                               else
4753                                                                 {
4754                                                                   /* 33222222222211111111110000000000
4755                                                                      10987654321098765432109876543210
4756                                                                      010001x0xx000011100xxxxxxxxxxxxx
4757                                                                      urshl.  */
4758                                                                   return 2300;
4759                                                                 }
4760                                                             }
4761                                                           else
4762                                                             {
4763                                                               if (((word >> 30) & 0x1) == 0)
4764                                                                 {
4765                                                                   /* 33222222222211111111110000000000
4766                                                                      10987654321098765432109876543210
4767                                                                      000001x0xx010011100xxxxxxxxxxxxx
4768                                                                      lsl.  */
4769                                                                   return 1727;
4770                                                                 }
4771                                                               else
4772                                                                 {
4773                                                                   /* 33222222222211111111110000000000
4774                                                                      10987654321098765432109876543210
4775                                                                      010001x0xx010011100xxxxxxxxxxxxx
4776                                                                      uhsub.  */
4777                                                                   return 2261;
4778                                                                 }
4779                                                             }
4780                                                         }
4781                                                       else
4782                                                         {
4783                                                           if (((word >> 20) & 0x1) == 0)
4784                                                             {
4785                                                               /* 33222222222211111111110000000000
4786                                                                  10987654321098765432109876543210
4787                                                                  0x0001x0xx001011100xxxxxxxxxxxxx
4788                                                                  uqrshl.  */
4789                                                               return 2285;
4790                                                             }
4791                                                           else
4792                                                             {
4793                                                               if (((word >> 30) & 0x1) == 0)
4794                                                                 {
4795                                                                   /* 33222222222211111111110000000000
4796                                                                      10987654321098765432109876543210
4797                                                                      000001x0xx011011100xxxxxxxxxxxxx
4798                                                                      lsl.  */
4799                                                                   return 1728;
4800                                                                 }
4801                                                               else
4802                                                                 {
4803                                                                   /* 33222222222211111111110000000000
4804                                                                      10987654321098765432109876543210
4805                                                                      010001x0xx011011100xxxxxxxxxxxxx
4806                                                                      uqsub.  */
4807                                                                   return 2294;
4808                                                                 }
4809                                                             }
4810                                                         }
4811                                                     }
4812                                                   else
4813                                                     {
4814                                                       if (((word >> 19) & 0x1) == 0)
4815                                                         {
4816                                                           if (((word >> 20) & 0x1) == 0)
4817                                                             {
4818                                                               if (((word >> 30) & 0x1) == 0)
4819                                                                 {
4820                                                                   /* 33222222222211111111110000000000
4821                                                                      10987654321098765432109876543210
4822                                                                      000001x0xx000111100xxxxxxxxxxxxx
4823                                                                      uqshl.  */
4824                                                                   return 2289;
4825                                                                 }
4826                                                               else
4827                                                                 {
4828                                                                   /* 33222222222211111111110000000000
4829                                                                      10987654321098765432109876543210
4830                                                                      010001x0xx000111100xxxxxxxxxxxxx
4831                                                                      urshlr.  */
4832                                                                   return 2301;
4833                                                                 }
4834                                                             }
4835                                                           else
4836                                                             {
4837                                                               if (((word >> 30) & 0x1) == 0)
4838                                                                 {
4839                                                                   /* 33222222222211111111110000000000
4840                                                                      10987654321098765432109876543210
4841                                                                      000001x0xx010111100xxxxxxxxxxxxx
4842                                                                      lslr.  */
4843                                                                   return 1730;
4844                                                                 }
4845                                                               else
4846                                                                 {
4847                                                                   /* 33222222222211111111110000000000
4848                                                                      10987654321098765432109876543210
4849                                                                      010001x0xx010111100xxxxxxxxxxxxx
4850                                                                      uhsubr.  */
4851                                                                   return 2262;
4852                                                                 }
4853                                                             }
4854                                                         }
4855                                                       else
4856                                                         {
4857                                                           if (((word >> 20) & 0x1) == 0)
4858                                                             {
4859                                                               if (((word >> 30) & 0x1) == 0)
4860                                                                 {
4861                                                                   /* 33222222222211111111110000000000
4862                                                                      10987654321098765432109876543210
4863                                                                      000001x0xx001111100xxxxxxxxxxxxx
4864                                                                      sqshlu.  */
4865                                                                   return 2212;
4866                                                                 }
4867                                                               else
4868                                                                 {
4869                                                                   /* 33222222222211111111110000000000
4870                                                                      10987654321098765432109876543210
4871                                                                      010001x0xx001111100xxxxxxxxxxxxx
4872                                                                      uqrshlr.  */
4873                                                                   return 2286;
4874                                                                 }
4875                                                             }
4876                                                           else
4877                                                             {
4878                                                               /* 33222222222211111111110000000000
4879                                                                  10987654321098765432109876543210
4880                                                                  0x0001x0xx011111100xxxxxxxxxxxxx
4881                                                                  uqsubr.  */
4882                                                               return 2295;
4883                                                             }
4884                                                         }
4885                                                     }
4886                                                 }
4887                                             }
4888                                         }
4889                                       else
4890                                         {
4891                                           if (((word >> 10) & 0x1) == 0)
4892                                             {
4893                                               if (((word >> 12) & 0x1) == 0)
4894                                                 {
4895                                                   if (((word >> 30) & 0x1) == 0)
4896                                                     {
4897                                                       /* 33222222222211111111110000000000
4898                                                          10987654321098765432109876543210
4899                                                          000001x0xx1xxxxx1000x0xxxxxxxxxx
4900                                                          asr.  */
4901                                                       return 1287;
4902                                                     }
4903                                                   else
4904                                                     {
4905                                                       if (((word >> 22) & 0x1) == 0)
4906                                                         {
4907                                                           /* 33222222222211111111110000000000
4908                                                              10987654321098765432109876543210
4909                                                              010001x0x01xxxxx1000x0xxxxxxxxxx
4910                                                              smlalb.  */
4911                                                           return 2140;
4912                                                         }
4913                                                       else
4914                                                         {
4915                                                           /* 33222222222211111111110000000000
4916                                                              10987654321098765432109876543210
4917                                                              010001x0x11xxxxx1000x0xxxxxxxxxx
4918                                                              smlalb.  */
4919                                                           return 2141;
4920                                                         }
4921                                                     }
4922                                                 }
4923                                               else
4924                                                 {
4925                                                   if (((word >> 30) & 0x1) == 0)
4926                                                     {
4927                                                       /* 33222222222211111111110000000000
4928                                                          10987654321098765432109876543210
4929                                                          000001x0xx1xxxxx1001x0xxxxxxxxxx
4930                                                          asr.  */
4931                                                       return 1288;
4932                                                     }
4933                                                   else
4934                                                     {
4935                                                       if (((word >> 22) & 0x1) == 0)
4936                                                         {
4937                                                           /* 33222222222211111111110000000000
4938                                                              10987654321098765432109876543210
4939                                                              010001x0x01xxxxx1001x0xxxxxxxxxx
4940                                                              umlalb.  */
4941                                                           return 2265;
4942                                                         }
4943                                                       else
4944                                                         {
4945                                                           /* 33222222222211111111110000000000
4946                                                              10987654321098765432109876543210
4947                                                              010001x0x11xxxxx1001x0xxxxxxxxxx
4948                                                              umlalb.  */
4949                                                           return 2266;
4950                                                         }
4951                                                     }
4952                                                 }
4953                                             }
4954                                           else
4955                                             {
4956                                               if (((word >> 12) & 0x1) == 0)
4957                                                 {
4958                                                   if (((word >> 30) & 0x1) == 0)
4959                                                     {
4960                                                       if (((word >> 11) & 0x1) == 0)
4961                                                         {
4962                                                           /* 33222222222211111111110000000000
4963                                                              10987654321098765432109876543210
4964                                                              000001x0xx1xxxxx100001xxxxxxxxxx
4965                                                              lsr.  */
4966                                                           return 1731;
4967                                                         }
4968                                                       else
4969                                                         {
4970                                                           /* 33222222222211111111110000000000
4971                                                              10987654321098765432109876543210
4972                                                              000001x0xx1xxxxx100011xxxxxxxxxx
4973                                                              lsl.  */
4974                                                           return 1725;
4975                                                         }
4976                                                     }
4977                                                   else
4978                                                     {
4979                                                       if (((word >> 22) & 0x1) == 0)
4980                                                         {
4981                                                           /* 33222222222211111111110000000000
4982                                                              10987654321098765432109876543210
4983                                                              010001x0x01xxxxx1000x1xxxxxxxxxx
4984                                                              smlalt.  */
4985                                                           return 2143;
4986                                                         }
4987                                                       else
4988                                                         {
4989                                                           /* 33222222222211111111110000000000
4990                                                              10987654321098765432109876543210
4991                                                              010001x0x11xxxxx1000x1xxxxxxxxxx
4992                                                              smlalt.  */
4993                                                           return 2144;
4994                                                         }
4995                                                     }
4996                                                 }
4997                                               else
4998                                                 {
4999                                                   if (((word >> 30) & 0x1) == 0)
5000                                                     {
5001                                                       if (((word >> 11) & 0x1) == 0)
5002                                                         {
5003                                                           /* 33222222222211111111110000000000
5004                                                              10987654321098765432109876543210
5005                                                              000001x0xx1xxxxx100101xxxxxxxxxx
5006                                                              lsr.  */
5007                                                           return 1732;
5008                                                         }
5009                                                       else
5010                                                         {
5011                                                           /* 33222222222211111111110000000000
5012                                                              10987654321098765432109876543210
5013                                                              000001x0xx1xxxxx100111xxxxxxxxxx
5014                                                              lsl.  */
5015                                                           return 1726;
5016                                                         }
5017                                                     }
5018                                                   else
5019                                                     {
5020                                                       if (((word >> 22) & 0x1) == 0)
5021                                                         {
5022                                                           /* 33222222222211111111110000000000
5023                                                              10987654321098765432109876543210
5024                                                              010001x0x01xxxxx1001x1xxxxxxxxxx
5025                                                              umlalt.  */
5026                                                           return 2268;
5027                                                         }
5028                                                       else
5029                                                         {
5030                                                           /* 33222222222211111111110000000000
5031                                                              10987654321098765432109876543210
5032                                                              010001x0x11xxxxx1001x1xxxxxxxxxx
5033                                                              umlalt.  */
5034                                                           return 2269;
5035                                                         }
5036                                                     }
5037                                                 }
5038                                             }
5039                                         }
5040                                     }
5041                                   else
5042                                     {
5043                                       if (((word >> 22) & 0x1) == 0)
5044                                         {
5045                                           if (((word >> 21) & 0x1) == 0)
5046                                             {
5047                                               if (((word >> 23) & 0x1) == 0)
5048                                                 {
5049                                                   /* 33222222222211111111110000000000
5050                                                      10987654321098765432109876543210
5051                                                      1x0001x0000xxxxx100xxxxxxxxxxxxx
5052                                                      ldnt1sb.  */
5053                                                   return 2092;
5054                                                 }
5055                                               else
5056                                                 {
5057                                                   /* 33222222222211111111110000000000
5058                                                      10987654321098765432109876543210
5059                                                      1x0001x0100xxxxx100xxxxxxxxxxxxx
5060                                                      ldnt1sh.  */
5061                                                   return 2093;
5062                                                 }
5063                                             }
5064                                           else
5065                                             {
5066                                               if (((word >> 23) & 0x1) == 0)
5067                                                 {
5068                                                   if (((word >> 30) & 0x1) == 0)
5069                                                     {
5070                                                       /* 33222222222211111111110000000000
5071                                                          10987654321098765432109876543210
5072                                                          100001x0001xxxxx100xxxxxxxxxxxxx
5073                                                          ld1sb.  */
5074                                                       return 1563;
5075                                                     }
5076                                                   else
5077                                                     {
5078                                                       /* 33222222222211111111110000000000
5079                                                          10987654321098765432109876543210
5080                                                          110001x0001xxxxx100xxxxxxxxxxxxx
5081                                                          ld1sb.  */
5082                                                       return 1567;
5083                                                     }
5084                                                 }
5085                                               else
5086                                                 {
5087                                                   if (((word >> 30) & 0x1) == 0)
5088                                                     {
5089                                                       /* 33222222222211111111110000000000
5090                                                          10987654321098765432109876543210
5091                                                          100001x0101xxxxx100xxxxxxxxxxxxx
5092                                                          ld1sh.  */
5093                                                       return 1576;
5094                                                     }
5095                                                   else
5096                                                     {
5097                                                       /* 33222222222211111111110000000000
5098                                                          10987654321098765432109876543210
5099                                                          110001x0101xxxxx100xxxxxxxxxxxxx
5100                                                          ld1sh.  */
5101                                                       return 1579;
5102                                                     }
5103                                                 }
5104                                             }
5105                                         }
5106                                       else
5107                                         {
5108                                           if (((word >> 23) & 0x1) == 0)
5109                                             {
5110                                               if (((word >> 30) & 0x1) == 0)
5111                                                 {
5112                                                   /* 33222222222211111111110000000000
5113                                                      10987654321098765432109876543210
5114                                                      100001x001xxxxxx100xxxxxxxxxxxxx
5115                                                      ld1rb.  */
5116                                                   return 1533;
5117                                                 }
5118                                               else
5119                                                 {
5120                                                   if (((word >> 21) & 0x1) == 0)
5121                                                     {
5122                                                       /* 33222222222211111111110000000000
5123                                                          10987654321098765432109876543210
5124                                                          110001x0010xxxxx100xxxxxxxxxxxxx
5125                                                          ld1sb.  */
5126                                                       return 1562;
5127                                                     }
5128                                                   else
5129                                                     {
5130                                                       /* 33222222222211111111110000000000
5131                                                          10987654321098765432109876543210
5132                                                          110001x0011xxxxx100xxxxxxxxxxxxx
5133                                                          prfb.  */
5134                                                       return 1765;
5135                                                     }
5136                                                 }
5137                                             }
5138                                           else
5139                                             {
5140                                               if (((word >> 30) & 0x1) == 0)
5141                                                 {
5142                                                   /* 33222222222211111111110000000000
5143                                                      10987654321098765432109876543210
5144                                                      100001x011xxxxxx100xxxxxxxxxxxxx
5145                                                      ld1rsw.  */
5146                                                   return 1554;
5147                                                 }
5148                                               else
5149                                                 {
5150                                                   if (((word >> 21) & 0x1) == 0)
5151                                                     {
5152                                                       /* 33222222222211111111110000000000
5153                                                          10987654321098765432109876543210
5154                                                          110001x0110xxxxx100xxxxxxxxxxxxx
5155                                                          ld1sh.  */
5156                                                       return 1574;
5157                                                     }
5158                                                   else
5159                                                     {
5160                                                       /* 33222222222211111111110000000000
5161                                                          10987654321098765432109876543210
5162                                                          110001x0111xxxxx100xxxxxxxxxxxxx
5163                                                          ld1sh.  */
5164                                                       return 1575;
5165                                                     }
5166                                                 }
5167                                             }
5168                                         }
5169                                     }
5170                                 }
5171                             }
5172                           else
5173                             {
5174                               if (((word >> 15) & 0x1) == 0)
5175                                 {
5176                                   if (((word >> 21) & 0x1) == 0)
5177                                     {
5178                                       if (((word >> 30) & 0x1) == 0)
5179                                         {
5180                                           if (((word >> 31) & 0x1) == 0)
5181                                             {
5182                                               /* 33222222222211111111110000000000
5183                                                  10987654321098765432109876543210
5184                                                  000001x0xx0xxxxx010xxxxxxxxxxxxx
5185                                                  mla.  */
5186                                               return 1738;
5187                                             }
5188                                           else
5189                                             {
5190                                               if (((word >> 23) & 0x1) == 0)
5191                                                 {
5192                                                   /* 33222222222211111111110000000000
5193                                                      10987654321098765432109876543210
5194                                                      100001x00x0xxxxx010xxxxxxxxxxxxx
5195                                                      ld1b.  */
5196                                                   return 1499;
5197                                                 }
5198                                               else
5199                                                 {
5200                                                   /* 33222222222211111111110000000000
5201                                                      10987654321098765432109876543210
5202                                                      100001x01x0xxxxx010xxxxxxxxxxxxx
5203                                                      ld1h.  */
5204                                                   return 1519;
5205                                                 }
5206                                             }
5207                                         }
5208                                       else
5209                                         {
5210                                           if (((word >> 31) & 0x1) == 0)
5211                                             {
5212                                               if (((word >> 10) & 0x1) == 0)
5213                                                 {
5214                                                   if (((word >> 11) & 0x1) == 0)
5215                                                     {
5216                                                       if (((word >> 12) & 0x1) == 0)
5217                                                         {
5218                                                           /* 33222222222211111111110000000000
5219                                                              10987654321098765432109876543210
5220                                                              010001x0xx0xxxxx010000xxxxxxxxxx
5221                                                              smlalb.  */
5222                                                           return 2142;
5223                                                         }
5224                                                       else
5225                                                         {
5226                                                           /* 33222222222211111111110000000000
5227                                                              10987654321098765432109876543210
5228                                                              010001x0xx0xxxxx010100xxxxxxxxxx
5229                                                              smlslb.  */
5230                                                           return 2148;
5231                                                         }
5232                                                     }
5233                                                   else
5234                                                     {
5235                                                       if (((word >> 12) & 0x1) == 0)
5236                                                         {
5237                                                           /* 33222222222211111111110000000000
5238                                                              10987654321098765432109876543210
5239                                                              010001x0xx0xxxxx010010xxxxxxxxxx
5240                                                              umlalb.  */
5241                                                           return 2267;
5242                                                         }
5243                                                       else
5244                                                         {
5245                                                           /* 33222222222211111111110000000000
5246                                                              10987654321098765432109876543210
5247                                                              010001x0xx0xxxxx010110xxxxxxxxxx
5248                                                              umlslb.  */
5249                                                           return 2273;
5250                                                         }
5251                                                     }
5252                                                 }
5253                                               else
5254                                                 {
5255                                                   if (((word >> 11) & 0x1) == 0)
5256                                                     {
5257                                                       if (((word >> 12) & 0x1) == 0)
5258                                                         {
5259                                                           /* 33222222222211111111110000000000
5260                                                              10987654321098765432109876543210
5261                                                              010001x0xx0xxxxx010001xxxxxxxxxx
5262                                                              smlalt.  */
5263                                                           return 2145;
5264                                                         }
5265                                                       else
5266                                                         {
5267                                                           /* 33222222222211111111110000000000
5268                                                              10987654321098765432109876543210
5269                                                              010001x0xx0xxxxx010101xxxxxxxxxx
5270                                                              smlslt.  */
5271                                                           return 2151;
5272                                                         }
5273                                                     }
5274                                                   else
5275                                                     {
5276                                                       if (((word >> 12) & 0x1) == 0)
5277                                                         {
5278                                                           /* 33222222222211111111110000000000
5279                                                              10987654321098765432109876543210
5280                                                              010001x0xx0xxxxx010011xxxxxxxxxx
5281                                                              umlalt.  */
5282                                                           return 2270;
5283                                                         }
5284                                                       else
5285                                                         {
5286                                                           /* 33222222222211111111110000000000
5287                                                              10987654321098765432109876543210
5288                                                              010001x0xx0xxxxx010111xxxxxxxxxx
5289                                                              umlslt.  */
5290                                                           return 2276;
5291                                                         }
5292                                                     }
5293                                                 }
5294                                             }
5295                                           else
5296                                             {
5297                                               if (((word >> 23) & 0x1) == 0)
5298                                                 {
5299                                                   /* 33222222222211111111110000000000
5300                                                      10987654321098765432109876543210
5301                                                      110001x00x0xxxxx010xxxxxxxxxxxxx
5302                                                      ld1b.  */
5303                                                   return 1504;
5304                                                 }
5305                                               else
5306                                                 {
5307                                                   /* 33222222222211111111110000000000
5308                                                      10987654321098765432109876543210
5309                                                      110001x01x0xxxxx010xxxxxxxxxxxxx
5310                                                      ld1h.  */
5311                                                   return 1524;
5312                                                 }
5313                                             }
5314                                         }
5315                                     }
5316                                   else
5317                                     {
5318                                       if (((word >> 30) & 0x1) == 0)
5319                                         {
5320                                           if (((word >> 31) & 0x1) == 0)
5321                                             {
5322                                               if (((word >> 11) & 0x1) == 0)
5323                                                 {
5324                                                   if (((word >> 12) & 0x1) == 0)
5325                                                     {
5326                                                       if (((word >> 10) & 0x1) == 0)
5327                                                         {
5328                                                           /* 33222222222211111111110000000000
5329                                                              10987654321098765432109876543210
5330                                                              000001x0xx1xxxxx010000xxxxxxxxxx
5331                                                              index.  */
5332                                                           return 1490;
5333                                                         }
5334                                                       else
5335                                                         {
5336                                                           /* 33222222222211111111110000000000
5337                                                              10987654321098765432109876543210
5338                                                              000001x0xx1xxxxx010001xxxxxxxxxx
5339                                                              index.  */
5340                                                           return 1491;
5341                                                         }
5342                                                     }
5343                                                   else
5344                                                     {
5345                                                       if (((word >> 22) & 0x1) == 0)
5346                                                         {
5347                                                           if (((word >> 23) & 0x1) == 0)
5348                                                             {
5349                                                               /* 33222222222211111111110000000000
5350                                                                  10987654321098765432109876543210
5351                                                                  000001x0001xxxxx01010xxxxxxxxxxx
5352                                                                  addvl.  */
5353                                                               return 1277;
5354                                                             }
5355                                                           else
5356                                                             {
5357                                                               /* 33222222222211111111110000000000
5358                                                                  10987654321098765432109876543210
5359                                                                  000001x0101xxxxx01010xxxxxxxxxxx
5360                                                                  rdvl.  */
5361                                                               return 1799;
5362                                                             }
5363                                                         }
5364                                                       else
5365                                                         {
5366                                                           /* 33222222222211111111110000000000
5367                                                              10987654321098765432109876543210
5368                                                              000001x0x11xxxxx01010xxxxxxxxxxx
5369                                                              addpl.  */
5370                                                           return 1276;
5371                                                         }
5372                                                     }
5373                                                 }
5374                                               else
5375                                                 {
5376                                                   if (((word >> 10) & 0x1) == 0)
5377                                                     {
5378                                                       /* 33222222222211111111110000000000
5379                                                          10987654321098765432109876543210
5380                                                          000001x0xx1xxxxx010x10xxxxxxxxxx
5381                                                          index.  */
5382                                                       return 1492;
5383                                                     }
5384                                                   else
5385                                                     {
5386                                                       /* 33222222222211111111110000000000
5387                                                          10987654321098765432109876543210
5388                                                          000001x0xx1xxxxx010x11xxxxxxxxxx
5389                                                          index.  */
5390                                                       return 1489;
5391                                                     }
5392                                                 }
5393                                             }
5394                                           else
5395                                             {
5396                                               if (((word >> 23) & 0x1) == 0)
5397                                                 {
5398                                                   /* 33222222222211111111110000000000
5399                                                      10987654321098765432109876543210
5400                                                      100001x00x1xxxxx010xxxxxxxxxxxxx
5401                                                      prfw.  */
5402                                                   return 1783;
5403                                                 }
5404                                               else
5405                                                 {
5406                                                   /* 33222222222211111111110000000000
5407                                                      10987654321098765432109876543210
5408                                                      100001x01x1xxxxx010xxxxxxxxxxxxx
5409                                                      ld1h.  */
5410                                                   return 1520;
5411                                                 }
5412                                             }
5413                                         }
5414                                       else
5415                                         {
5416                                           if (((word >> 23) & 0x1) == 0)
5417                                             {
5418                                               /* 33222222222211111111110000000000
5419                                                  10987654321098765432109876543210
5420                                                  x10001x00x1xxxxx010xxxxxxxxxxxxx
5421                                                  prfw.  */
5422                                               return 1785;
5423                                             }
5424                                           else
5425                                             {
5426                                               if (((word >> 31) & 0x1) == 0)
5427                                                 {
5428                                                   if (((word >> 22) & 0x1) == 0)
5429                                                     {
5430                                                       /* 33222222222211111111110000000000
5431                                                          10987654321098765432109876543210
5432                                                          010001x0101xxxxx010xxxxxxxxxxxxx
5433                                                          cdot.  */
5434                                                       return 2057;
5435                                                     }
5436                                                   else
5437                                                     {
5438                                                       /* 33222222222211111111110000000000
5439                                                          10987654321098765432109876543210
5440                                                          010001x0111xxxxx010xxxxxxxxxxxxx
5441                                                          cdot.  */
5442                                                       return 2056;
5443                                                     }
5444                                                 }
5445                                               else
5446                                                 {
5447                                                   /* 33222222222211111111110000000000
5448                                                      10987654321098765432109876543210
5449                                                      110001x01x1xxxxx010xxxxxxxxxxxxx
5450                                                      ld1h.  */
5451                                                   return 1525;
5452                                                 }
5453                                             }
5454                                         }
5455                                     }
5456                                 }
5457                               else
5458                                 {
5459                                   if (((word >> 30) & 0x1) == 0)
5460                                     {
5461                                       if (((word >> 31) & 0x1) == 0)
5462                                         {
5463                                           if (((word >> 21) & 0x1) == 0)
5464                                             {
5465                                               /* 33222222222211111111110000000000
5466                                                  10987654321098765432109876543210
5467                                                  000001x0xx0xxxxx110xxxxxxxxxxxxx
5468                                                  mad.  */
5469                                               return 1737;
5470                                             }
5471                                           else
5472                                             {
5473                                               if (((word >> 10) & 0x1) == 0)
5474                                                 {
5475                                                   if (((word >> 11) & 0x1) == 0)
5476                                                     {
5477                                                       if (((word >> 20) & 0x1) == 0)
5478                                                         {
5479                                                           if (((word >> 22) & 0x1) == 0)
5480                                                             {
5481                                                               /* 33222222222211111111110000000000
5482                                                                  10987654321098765432109876543210
5483                                                                  000001x0x010xxxx110x00xxxxxxxxxx
5484                                                                  sqincw.  */
5485                                                               return 1857;
5486                                                             }
5487                                                           else
5488                                                             {
5489                                                               if (((word >> 23) & 0x1) == 0)
5490                                                                 {
5491                                                                   /* 33222222222211111111110000000000
5492                                                                      10987654321098765432109876543210
5493                                                                      000001x00110xxxx110x00xxxxxxxxxx
5494                                                                      sqinch.  */
5495                                                                   return 1851;
5496                                                                 }
5497                                                               else
5498                                                                 {
5499                                                                   /* 33222222222211111111110000000000
5500                                                                      10987654321098765432109876543210
5501                                                                      000001x01110xxxx110x00xxxxxxxxxx
5502                                                                      sqincd.  */
5503                                                                   return 1848;
5504                                                                 }
5505                                                             }
5506                                                         }
5507                                                       else
5508                                                         {
5509                                                           if (((word >> 22) & 0x1) == 0)
5510                                                             {
5511                                                               /* 33222222222211111111110000000000
5512                                                                  10987654321098765432109876543210
5513                                                                  000001x0x011xxxx110x00xxxxxxxxxx
5514                                                                  incw.  */
5515                                                               return 1487;
5516                                                             }
5517                                                           else
5518                                                             {
5519                                                               if (((word >> 23) & 0x1) == 0)
5520                                                                 {
5521                                                                   /* 33222222222211111111110000000000
5522                                                                      10987654321098765432109876543210
5523                                                                      000001x00111xxxx110x00xxxxxxxxxx
5524                                                                      inch.  */
5525                                                                   return 1483;
5526                                                                 }
5527                                                               else
5528                                                                 {
5529                                                                   /* 33222222222211111111110000000000
5530                                                                      10987654321098765432109876543210
5531                                                                      000001x01111xxxx110x00xxxxxxxxxx
5532                                                                      incd.  */
5533                                                                   return 1481;
5534                                                                 }
5535                                                             }
5536                                                         }
5537                                                     }
5538                                                   else
5539                                                     {
5540                                                       if (((word >> 22) & 0x1) == 0)
5541                                                         {
5542                                                           /* 33222222222211111111110000000000
5543                                                              10987654321098765432109876543210
5544                                                              000001x0x01xxxxx110x10xxxxxxxxxx
5545                                                              sqdecw.  */
5546                                                           return 1843;
5547                                                         }
5548                                                       else
5549                                                         {
5550                                                           if (((word >> 23) & 0x1) == 0)
5551                                                             {
5552                                                               /* 33222222222211111111110000000000
5553                                                                  10987654321098765432109876543210
5554                                                                  000001x0011xxxxx110x10xxxxxxxxxx
5555                                                                  sqdech.  */
5556                                                               return 1837;
5557                                                             }
5558                                                           else
5559                                                             {
5560                                                               /* 33222222222211111111110000000000
5561                                                                  10987654321098765432109876543210
5562                                                                  000001x0111xxxxx110x10xxxxxxxxxx
5563                                                                  sqdecd.  */
5564                                                               return 1834;
5565                                                             }
5566                                                         }
5567                                                     }
5568                                                 }
5569                                               else
5570                                                 {
5571                                                   if (((word >> 11) & 0x1) == 0)
5572                                                     {
5573                                                       if (((word >> 20) & 0x1) == 0)
5574                                                         {
5575                                                           if (((word >> 22) & 0x1) == 0)
5576                                                             {
5577                                                               /* 33222222222211111111110000000000
5578                                                                  10987654321098765432109876543210
5579                                                                  000001x0x010xxxx110x01xxxxxxxxxx
5580                                                                  uqincw.  */
5581                                                               return 2005;
5582                                                             }
5583                                                           else
5584                                                             {
5585                                                               if (((word >> 23) & 0x1) == 0)
5586                                                                 {
5587                                                                   /* 33222222222211111111110000000000
5588                                                                      10987654321098765432109876543210
5589                                                                      000001x00110xxxx110x01xxxxxxxxxx
5590                                                                      uqinch.  */
5591                                                                   return 1999;
5592                                                                 }
5593                                                               else
5594                                                                 {
5595                                                                   /* 33222222222211111111110000000000
5596                                                                      10987654321098765432109876543210
5597                                                                      000001x01110xxxx110x01xxxxxxxxxx
5598                                                                      uqincd.  */
5599                                                                   return 1996;
5600                                                                 }
5601                                                             }
5602                                                         }
5603                                                       else
5604                                                         {
5605                                                           if (((word >> 22) & 0x1) == 0)
5606                                                             {
5607                                                               /* 33222222222211111111110000000000
5608                                                                  10987654321098765432109876543210
5609                                                                  000001x0x011xxxx110x01xxxxxxxxxx
5610                                                                  decw.  */
5611                                                               return 1362;
5612                                                             }
5613                                                           else
5614                                                             {
5615                                                               if (((word >> 23) & 0x1) == 0)
5616                                                                 {
5617                                                                   /* 33222222222211111111110000000000
5618                                                                      10987654321098765432109876543210
5619                                                                      000001x00111xxxx110x01xxxxxxxxxx
5620                                                                      dech.  */
5621                                                                   return 1358;
5622                                                                 }
5623                                                               else
5624                                                                 {
5625                                                                   /* 33222222222211111111110000000000
5626                                                                      10987654321098765432109876543210
5627                                                                      000001x01111xxxx110x01xxxxxxxxxx
5628                                                                      decd.  */
5629                                                                   return 1356;
5630                                                                 }
5631                                                             }
5632                                                         }
5633                                                     }
5634                                                   else
5635                                                     {
5636                                                       if (((word >> 22) & 0x1) == 0)
5637                                                         {
5638                                                           /* 33222222222211111111110000000000
5639                                                              10987654321098765432109876543210
5640                                                              000001x0x01xxxxx110x11xxxxxxxxxx
5641                                                              uqdecw.  */
5642                                                           return 1991;
5643                                                         }
5644                                                       else
5645                                                         {
5646                                                           if (((word >> 23) & 0x1) == 0)
5647                                                             {
5648                                                               /* 33222222222211111111110000000000
5649                                                                  10987654321098765432109876543210
5650                                                                  000001x0011xxxxx110x11xxxxxxxxxx
5651                                                                  uqdech.  */
5652                                                               return 1985;
5653                                                             }
5654                                                           else
5655                                                             {
5656                                                               /* 33222222222211111111110000000000
5657                                                                  10987654321098765432109876543210
5658                                                                  000001x0111xxxxx110x11xxxxxxxxxx
5659                                                                  uqdecd.  */
5660                                                               return 1982;
5661                                                             }
5662                                                         }
5663                                                     }
5664                                                 }
5665                                             }
5666                                         }
5667                                       else
5668                                         {
5669                                           if (((word >> 22) & 0x1) == 0)
5670                                             {
5671                                               if (((word >> 21) & 0x1) == 0)
5672                                                 {
5673                                                   if (((word >> 23) & 0x1) == 0)
5674                                                     {
5675                                                       /* 33222222222211111111110000000000
5676                                                          10987654321098765432109876543210
5677                                                          100001x0000xxxxx110xxxxxxxxxxxxx
5678                                                          prfb.  */
5679                                                       return 1762;
5680                                                     }
5681                                                   else
5682                                                     {
5683                                                       /* 33222222222211111111110000000000
5684                                                          10987654321098765432109876543210
5685                                                          100001x0100xxxxx110xxxxxxxxxxxxx
5686                                                          prfh.  */
5687                                                       return 1777;
5688                                                     }
5689                                                 }
5690                                               else
5691                                                 {
5692                                                   if (((word >> 23) & 0x1) == 0)
5693                                                     {
5694                                                       /* 33222222222211111111110000000000
5695                                                          10987654321098765432109876543210
5696                                                          100001x0001xxxxx110xxxxxxxxxxxxx
5697                                                          ld1b.  */
5698                                                       return 1506;
5699                                                     }
5700                                                   else
5701                                                     {
5702                                                       /* 33222222222211111111110000000000
5703                                                          10987654321098765432109876543210
5704                                                          100001x0101xxxxx110xxxxxxxxxxxxx
5705                                                          ld1h.  */
5706                                                       return 1528;
5707                                                     }
5708                                                 }
5709                                             }
5710                                           else
5711                                             {
5712                                               if (((word >> 23) & 0x1) == 0)
5713                                                 {
5714                                                   /* 33222222222211111111110000000000
5715                                                      10987654321098765432109876543210
5716                                                      100001x001xxxxxx110xxxxxxxxxxxxx
5717                                                      ld1rb.  */
5718                                                   return 1535;
5719                                                 }
5720                                               else
5721                                                 {
5722                                                   /* 33222222222211111111110000000000
5723                                                      10987654321098765432109876543210
5724                                                      100001x011xxxxxx110xxxxxxxxxxxxx
5725                                                      ld1rh.  */
5726                                                   return 1539;
5727                                                 }
5728                                             }
5729                                         }
5730                                     }
5731                                   else
5732                                     {
5733                                       if (((word >> 21) & 0x1) == 0)
5734                                         {
5735                                           if (((word >> 22) & 0x1) == 0)
5736                                             {
5737                                               if (((word >> 23) & 0x1) == 0)
5738                                                 {
5739                                                   /* 33222222222211111111110000000000
5740                                                      10987654321098765432109876543210
5741                                                      x10001x0000xxxxx110xxxxxxxxxxxxx
5742                                                      ldnt1b.  */
5743                                                   return 2088;
5744                                                 }
5745                                               else
5746                                                 {
5747                                                   /* 33222222222211111111110000000000
5748                                                      10987654321098765432109876543210
5749                                                      x10001x0100xxxxx110xxxxxxxxxxxxx
5750                                                      ldnt1h.  */
5751                                                   return 2091;
5752                                                 }
5753                                             }
5754                                           else
5755                                             {
5756                                               if (((word >> 23) & 0x1) == 0)
5757                                                 {
5758                                                   /* 33222222222211111111110000000000
5759                                                      10987654321098765432109876543210
5760                                                      x10001x0010xxxxx110xxxxxxxxxxxxx
5761                                                      ld1b.  */
5762                                                   return 1505;
5763                                                 }
5764                                               else
5765                                                 {
5766                                                   /* 33222222222211111111110000000000
5767                                                      10987654321098765432109876543210
5768                                                      x10001x0110xxxxx110xxxxxxxxxxxxx
5769                                                      ld1h.  */
5770                                                   return 1526;
5771                                                 }
5772                                             }
5773                                         }
5774                                       else
5775                                         {
5776                                           if (((word >> 22) & 0x1) == 0)
5777                                             {
5778                                               if (((word >> 23) & 0x1) == 0)
5779                                                 {
5780                                                   /* 33222222222211111111110000000000
5781                                                      10987654321098765432109876543210
5782                                                      x10001x0001xxxxx110xxxxxxxxxxxxx
5783                                                      ld1b.  */
5784                                                   return 1511;
5785                                                 }
5786                                               else
5787                                                 {
5788                                                   if (((word >> 31) & 0x1) == 0)
5789                                                     {
5790                                                       if (((word >> 10) & 0x1) == 0)
5791                                                         {
5792                                                           if (((word >> 12) & 0x1) == 0)
5793                                                             {
5794                                                               /* 33222222222211111111110000000000
5795                                                                  10987654321098765432109876543210
5796                                                                  010001x0101xxxxx1100x0xxxxxxxxxx
5797                                                                  smullb.  */
5798                                                               return 2153;
5799                                                             }
5800                                                           else
5801                                                             {
5802                                                               /* 33222222222211111111110000000000
5803                                                                  10987654321098765432109876543210
5804                                                                  010001x0101xxxxx1101x0xxxxxxxxxx
5805                                                                  umullb.  */
5806                                                               return 2278;
5807                                                             }
5808                                                         }
5809                                                       else
5810                                                         {
5811                                                           if (((word >> 12) & 0x1) == 0)
5812                                                             {
5813                                                               /* 33222222222211111111110000000000
5814                                                                  10987654321098765432109876543210
5815                                                                  010001x0101xxxxx1100x1xxxxxxxxxx
5816                                                                  smullt.  */
5817                                                               return 2156;
5818                                                             }
5819                                                           else
5820                                                             {
5821                                                               /* 33222222222211111111110000000000
5822                                                                  10987654321098765432109876543210
5823                                                                  010001x0101xxxxx1101x1xxxxxxxxxx
5824                                                                  umullt.  */
5825                                                               return 2281;
5826                                                             }
5827                                                         }
5828                                                     }
5829                                                   else
5830                                                     {
5831                                                       /* 33222222222211111111110000000000
5832                                                          10987654321098765432109876543210
5833                                                          110001x0101xxxxx110xxxxxxxxxxxxx
5834                                                          ld1h.  */
5835                                                       return 1532;
5836                                                     }
5837                                                 }
5838                                             }
5839                                           else
5840                                             {
5841                                               if (((word >> 23) & 0x1) == 0)
5842                                                 {
5843                                                   /* 33222222222211111111110000000000
5844                                                      10987654321098765432109876543210
5845                                                      x10001x0011xxxxx110xxxxxxxxxxxxx
5846                                                      prfw.  */
5847                                                   return 1786;
5848                                                 }
5849                                               else
5850                                                 {
5851                                                   if (((word >> 31) & 0x1) == 0)
5852                                                     {
5853                                                       if (((word >> 10) & 0x1) == 0)
5854                                                         {
5855                                                           if (((word >> 12) & 0x1) == 0)
5856                                                             {
5857                                                               /* 33222222222211111111110000000000
5858                                                                  10987654321098765432109876543210
5859                                                                  010001x0111xxxxx1100x0xxxxxxxxxx
5860                                                                  smullb.  */
5861                                                               return 2154;
5862                                                             }
5863                                                           else
5864                                                             {
5865                                                               /* 33222222222211111111110000000000
5866                                                                  10987654321098765432109876543210
5867                                                                  010001x0111xxxxx1101x0xxxxxxxxxx
5868                                                                  umullb.  */
5869                                                               return 2279;
5870                                                             }
5871                                                         }
5872                                                       else
5873                                                         {
5874                                                           if (((word >> 12) & 0x1) == 0)
5875                                                             {
5876                                                               /* 33222222222211111111110000000000
5877                                                                  10987654321098765432109876543210
5878                                                                  010001x0111xxxxx1100x1xxxxxxxxxx
5879                                                                  smullt.  */
5880                                                               return 2157;
5881                                                             }
5882                                                           else
5883                                                             {
5884                                                               /* 33222222222211111111110000000000
5885                                                                  10987654321098765432109876543210
5886                                                                  010001x0111xxxxx1101x1xxxxxxxxxx
5887                                                                  umullt.  */
5888                                                               return 2282;
5889                                                             }
5890                                                         }
5891                                                     }
5892                                                   else
5893                                                     {
5894                                                       /* 33222222222211111111110000000000
5895                                                          10987654321098765432109876543210
5896                                                          110001x0111xxxxx110xxxxxxxxxxxxx
5897                                                          ld1h.  */
5898                                                       return 1527;
5899                                                     }
5900                                                 }
5901                                             }
5902                                         }
5903                                     }
5904                                 }
5905                             }
5906                         }
5907                       else
5908                         {
5909                           if (((word >> 14) & 0x1) == 0)
5910                             {
5911                               if (((word >> 15) & 0x1) == 0)
5912                                 {
5913                                   if (((word >> 21) & 0x1) == 0)
5914                                     {
5915                                       if (((word >> 30) & 0x1) == 0)
5916                                         {
5917                                           if (((word >> 31) & 0x1) == 0)
5918                                             {
5919                                               if (((word >> 17) & 0x1) == 0)
5920                                                 {
5921                                                   if (((word >> 19) & 0x1) == 0)
5922                                                     {
5923                                                       if (((word >> 20) & 0x1) == 0)
5924                                                         {
5925                                                           if (((word >> 16) & 0x1) == 0)
5926                                                             {
5927                                                               /* 33222222222211111111110000000000
5928                                                                  10987654321098765432109876543210
5929                                                                  000001x0xx000x00001xxxxxxxxxxxxx
5930                                                                  saddv.  */
5931                                                               return 1806;
5932                                                             }
5933                                                           else
5934                                                             {
5935                                                               /* 33222222222211111111110000000000
5936                                                                  10987654321098765432109876543210
5937                                                                  000001x0xx000x01001xxxxxxxxxxxxx
5938                                                                  uaddv.  */
5939                                                               return 1958;
5940                                                             }
5941                                                         }
5942                                                       else
5943                                                         {
5944                                                           /* 33222222222211111111110000000000
5945                                                              10987654321098765432109876543210
5946                                                              000001x0xx010x0x001xxxxxxxxxxxxx
5947                                                              movprfx.  */
5948                                                           return 1741;
5949                                                         }
5950                                                     }
5951                                                   else
5952                                                     {
5953                                                       if (((word >> 16) & 0x1) == 0)
5954                                                         {
5955                                                           if (((word >> 20) & 0x1) == 0)
5956                                                             {
5957                                                               /* 33222222222211111111110000000000
5958                                                                  10987654321098765432109876543210
5959                                                                  000001x0xx001x00001xxxxxxxxxxxxx
5960                                                                  smaxv.  */
5961                                                               return 1824;
5962                                                             }
5963                                                           else
5964                                                             {
5965                                                               /* 33222222222211111111110000000000
5966                                                                  10987654321098765432109876543210
5967                                                                  000001x0xx011x00001xxxxxxxxxxxxx
5968                                                                  orv.  */
5969                                                               return 1758;
5970                                                             }
5971                                                         }
5972                                                       else
5973                                                         {
5974                                                           if (((word >> 20) & 0x1) == 0)
5975                                                             {
5976                                                               /* 33222222222211111111110000000000
5977                                                                  10987654321098765432109876543210
5978                                                                  000001x0xx001x01001xxxxxxxxxxxxx
5979                                                                  umaxv.  */
5980                                                               return 1973;
5981                                                             }
5982                                                           else
5983                                                             {
5984                                                               /* 33222222222211111111110000000000
5985                                                                  10987654321098765432109876543210
5986                                                                  000001x0xx011x01001xxxxxxxxxxxxx
5987                                                                  eorv.  */
5988                                                               return 1373;
5989                                                             }
5990                                                         }
5991                                                     }
5992                                                 }
5993                                               else
5994                                                 {
5995                                                   if (((word >> 16) & 0x1) == 0)
5996                                                     {
5997                                                       if (((word >> 20) & 0x1) == 0)
5998                                                         {
5999                                                           /* 33222222222211111111110000000000
6000                                                              10987654321098765432109876543210
6001                                                              000001x0xx00xx10001xxxxxxxxxxxxx
6002                                                              sminv.  */
6003                                                           return 1827;
6004                                                         }
6005                                                       else
6006                                                         {
6007                                                           /* 33222222222211111111110000000000
6008                                                              10987654321098765432109876543210
6009                                                              000001x0xx01xx10001xxxxxxxxxxxxx
6010                                                              andv.  */
6011                                                           return 1286;
6012                                                         }
6013                                                     }
6014                                                   else
6015                                                     {
6016                                                       /* 33222222222211111111110000000000
6017                                                          10987654321098765432109876543210
6018                                                          000001x0xx0xxx11001xxxxxxxxxxxxx
6019                                                          uminv.  */
6020                                                       return 1976;
6021                                                     }
6022                                                 }
6023                                             }
6024                                           else
6025                                             {
6026                                               if (((word >> 23) & 0x1) == 0)
6027                                                 {
6028                                                   /* 33222222222211111111110000000000
6029                                                      10987654321098765432109876543210
6030                                                      100001x00x0xxxxx001xxxxxxxxxxxxx
6031                                                      ldff1sb.  */
6032                                                   return 1657;
6033                                                 }
6034                                               else
6035                                                 {
6036                                                   /* 33222222222211111111110000000000
6037                                                      10987654321098765432109876543210
6038                                                      100001x01x0xxxxx001xxxxxxxxxxxxx
6039                                                      ldff1sh.  */
6040                                                   return 1668;
6041                                                 }
6042                                             }
6043                                         }
6044                                       else
6045                                         {
6046                                           if (((word >> 31) & 0x1) == 0)
6047                                             {
6048                                               if (((word >> 12) & 0x1) == 0)
6049                                                 {
6050                                                   /* 33222222222211111111110000000000
6051                                                      10987654321098765432109876543210
6052                                                      010001x0xx0xxxxx0010xxxxxxxxxxxx
6053                                                      cmla.  */
6054                                                   return 2058;
6055                                                 }
6056                                               else
6057                                                 {
6058                                                   /* 33222222222211111111110000000000
6059                                                      10987654321098765432109876543210
6060                                                      010001x0xx0xxxxx0011xxxxxxxxxxxx
6061                                                      sqrdcmlah.  */
6062                                                   return 2190;
6063                                                 }
6064                                             }
6065                                           else
6066                                             {
6067                                               if (((word >> 23) & 0x1) == 0)
6068                                                 {
6069                                                   /* 33222222222211111111110000000000
6070                                                      10987654321098765432109876543210
6071                                                      110001x00x0xxxxx001xxxxxxxxxxxxx
6072                                                      ldff1sb.  */
6073                                                   return 1664;
6074                                                 }
6075                                               else
6076                                                 {
6077                                                   /* 33222222222211111111110000000000
6078                                                      10987654321098765432109876543210
6079                                                      110001x01x0xxxxx001xxxxxxxxxxxxx
6080                                                      ldff1sh.  */
6081                                                   return 1674;
6082                                                 }
6083                                             }
6084                                         }
6085                                     }
6086                                   else
6087                                     {
6088                                       if (((word >> 30) & 0x1) == 0)
6089                                         {
6090                                           if (((word >> 31) & 0x1) == 0)
6091                                             {
6092                                               if (((word >> 10) & 0x1) == 0)
6093                                                 {
6094                                                   if (((word >> 11) & 0x1) == 0)
6095                                                     {
6096                                                       if (((word >> 22) & 0x1) == 0)
6097                                                         {
6098                                                           if (((word >> 23) & 0x1) == 0)
6099                                                             {
6100                                                               /* 33222222222211111111110000000000
6101                                                                  10987654321098765432109876543210
6102                                                                  000001x0001xxxxx001x00xxxxxxxxxx
6103                                                                  and.  */
6104                                                               return 1281;
6105                                                             }
6106                                                           else
6107                                                             {
6108                                                               /* 33222222222211111111110000000000
6109                                                                  10987654321098765432109876543210
6110                                                                  000001x0101xxxxx001x00xxxxxxxxxx
6111                                                                  eor.  */
6112                                                               return 1368;
6113                                                             }
6114                                                         }
6115                                                       else
6116                                                         {
6117                                                           if (((word >> 23) & 0x1) == 0)
6118                                                             {
6119                                                               /* 33222222222211111111110000000000
6120                                                                  10987654321098765432109876543210
6121                                                                  000001x0011xxxxx001x00xxxxxxxxxx
6122                                                                  orr.  */
6123                                                               return 1753;
6124                                                             }
6125                                                           else
6126                                                             {
6127                                                               /* 33222222222211111111110000000000
6128                                                                  10987654321098765432109876543210
6129                                                                  000001x0111xxxxx001x00xxxxxxxxxx
6130                                                                  bic.  */
6131                                                               return 1294;
6132                                                             }
6133                                                         }
6134                                                     }
6135                                                   else
6136                                                     {
6137                                                       if (((word >> 22) & 0x1) == 0)
6138                                                         {
6139                                                           /* 33222222222211111111110000000000
6140                                                              10987654321098765432109876543210
6141                                                              000001x0x01xxxxx001x10xxxxxxxxxx
6142                                                              eor3.  */
6143                                                           return 2061;
6144                                                         }
6145                                                       else
6146                                                         {
6147                                                           /* 33222222222211111111110000000000
6148                                                              10987654321098765432109876543210
6149                                                              000001x0x11xxxxx001x10xxxxxxxxxx
6150                                                              bcax.  */
6151                                                           return 2050;
6152                                                         }
6153                                                     }
6154                                                 }
6155                                               else
6156                                                 {
6157                                                   if (((word >> 11) & 0x1) == 0)
6158                                                     {
6159                                                       /* 33222222222211111111110000000000
6160                                                          10987654321098765432109876543210
6161                                                          000001x0xx1xxxxx001x01xxxxxxxxxx
6162                                                          xar.  */
6163                                                       return 2323;
6164                                                     }
6165                                                   else
6166                                                     {
6167                                                       if (((word >> 22) & 0x1) == 0)
6168                                                         {
6169                                                           if (((word >> 23) & 0x1) == 0)
6170                                                             {
6171                                                               /* 33222222222211111111110000000000
6172                                                                  10987654321098765432109876543210
6173                                                                  000001x0001xxxxx001x11xxxxxxxxxx
6174                                                                  bsl.  */
6175                                                               return 2051;
6176                                                             }
6177                                                           else
6178                                                             {
6179                                                               /* 33222222222211111111110000000000
6180                                                                  10987654321098765432109876543210
6181                                                                  000001x0101xxxxx001x11xxxxxxxxxx
6182                                                                  bsl2n.  */
6183                                                               return 2053;
6184                                                             }
6185                                                         }
6186                                                       else
6187                                                         {
6188                                                           if (((word >> 23) & 0x1) == 0)
6189                                                             {
6190                                                               /* 33222222222211111111110000000000
6191                                                                  10987654321098765432109876543210
6192                                                                  000001x0011xxxxx001x11xxxxxxxxxx
6193                                                                  bsl1n.  */
6194                                                               return 2052;
6195                                                             }
6196                                                           else
6197                                                             {
6198                                                               /* 33222222222211111111110000000000
6199                                                                  10987654321098765432109876543210
6200                                                                  000001x0111xxxxx001x11xxxxxxxxxx
6201                                                                  nbsl.  */
6202                                                               return 2108;
6203                                                             }
6204                                                         }
6205                                                     }
6206                                                 }
6207                                             }
6208                                           else
6209                                             {
6210                                               if (((word >> 23) & 0x1) == 0)
6211                                                 {
6212                                                   /* 33222222222211111111110000000000
6213                                                      10987654321098765432109876543210
6214                                                      100001x00x1xxxxx001xxxxxxxxxxxxx
6215                                                      prfh.  */
6216                                                   return 1776;
6217                                                 }
6218                                               else
6219                                                 {
6220                                                   /* 33222222222211111111110000000000
6221                                                      10987654321098765432109876543210
6222                                                      100001x01x1xxxxx001xxxxxxxxxxxxx
6223                                                      ldff1sh.  */
6224                                                   return 1669;
6225                                                 }
6226                                             }
6227                                         }
6228                                       else
6229                                         {
6230                                           if (((word >> 23) & 0x1) == 0)
6231                                             {
6232                                               /* 33222222222211111111110000000000
6233                                                  10987654321098765432109876543210
6234                                                  x10001x00x1xxxxx001xxxxxxxxxxxxx
6235                                                  prfh.  */
6236                                               return 1778;
6237                                             }
6238                                           else
6239                                             {
6240                                               if (((word >> 31) & 0x1) == 0)
6241                                                 {
6242                                                   if (((word >> 10) & 0x1) == 0)
6243                                                     {
6244                                                       if (((word >> 12) & 0x1) == 0)
6245                                                         {
6246                                                           if (((word >> 22) & 0x1) == 0)
6247                                                             {
6248                                                               /* 33222222222211111111110000000000
6249                                                                  10987654321098765432109876543210
6250                                                                  010001x0101xxxxx0010x0xxxxxxxxxx
6251                                                                  sqdmlalb.  */
6252                                                               return 2163;
6253                                                             }
6254                                                           else
6255                                                             {
6256                                                               /* 33222222222211111111110000000000
6257                                                                  10987654321098765432109876543210
6258                                                                  010001x0111xxxxx0010x0xxxxxxxxxx
6259                                                                  sqdmlalb.  */
6260                                                               return 2164;
6261                                                             }
6262                                                         }
6263                                                       else
6264                                                         {
6265                                                           if (((word >> 22) & 0x1) == 0)
6266                                                             {
6267                                                               /* 33222222222211111111110000000000
6268                                                                  10987654321098765432109876543210
6269                                                                  010001x0101xxxxx0011x0xxxxxxxxxx
6270                                                                  sqdmlslb.  */
6271                                                               return 2170;
6272                                                             }
6273                                                           else
6274                                                             {
6275                                                               /* 33222222222211111111110000000000
6276                                                                  10987654321098765432109876543210
6277                                                                  010001x0111xxxxx0011x0xxxxxxxxxx
6278                                                                  sqdmlslb.  */
6279                                                               return 2171;
6280                                                             }
6281                                                         }
6282                                                     }
6283                                                   else
6284                                                     {
6285                                                       if (((word >> 12) & 0x1) == 0)
6286                                                         {
6287                                                           if (((word >> 22) & 0x1) == 0)
6288                                                             {
6289                                                               /* 33222222222211111111110000000000
6290                                                                  10987654321098765432109876543210
6291                                                                  010001x0101xxxxx0010x1xxxxxxxxxx
6292                                                                  sqdmlalt.  */
6293                                                               return 2167;
6294                                                             }
6295                                                           else
6296                                                             {
6297                                                               /* 33222222222211111111110000000000
6298                                                                  10987654321098765432109876543210
6299                                                                  010001x0111xxxxx0010x1xxxxxxxxxx
6300                                                                  sqdmlalt.  */
6301                                                               return 2168;
6302                                                             }
6303                                                         }
6304                                                       else
6305                                                         {
6306                                                           if (((word >> 22) & 0x1) == 0)
6307                                                             {
6308                                                               /* 33222222222211111111110000000000
6309                                                                  10987654321098765432109876543210
6310                                                                  010001x0101xxxxx0011x1xxxxxxxxxx
6311                                                                  sqdmlslt.  */
6312                                                               return 2174;
6313                                                             }
6314                                                           else
6315                                                             {
6316                                                               /* 33222222222211111111110000000000
6317                                                                  10987654321098765432109876543210
6318                                                                  010001x0111xxxxx0011x1xxxxxxxxxx
6319                                                                  sqdmlslt.  */
6320                                                               return 2175;
6321                                                             }
6322                                                         }
6323                                                     }
6324                                                 }
6325                                               else
6326                                                 {
6327                                                   /* 33222222222211111111110000000000
6328                                                      10987654321098765432109876543210
6329                                                      110001x01x1xxxxx001xxxxxxxxxxxxx
6330                                                      ldff1sh.  */
6331                                                   return 1675;
6332                                                 }
6333                                             }
6334                                         }
6335                                     }
6336                                 }
6337                               else
6338                                 {
6339                                   if (((word >> 30) & 0x1) == 0)
6340                                     {
6341                                       if (((word >> 31) & 0x1) == 0)
6342                                         {
6343                                           if (((word >> 21) & 0x1) == 0)
6344                                             {
6345                                               if (((word >> 16) & 0x1) == 0)
6346                                                 {
6347                                                   if (((word >> 17) & 0x1) == 0)
6348                                                     {
6349                                                       if (((word >> 18) & 0x1) == 0)
6350                                                         {
6351                                                           if (((word >> 19) & 0x1) == 0)
6352                                                             {
6353                                                               /* 33222222222211111111110000000000
6354                                                                  10987654321098765432109876543210
6355                                                                  000001x0xx0x0000101xxxxxxxxxxxxx
6356                                                                  sxtb.  */
6357                                                               return 1949;
6358                                                             }
6359                                                           else
6360                                                             {
6361                                                               /* 33222222222211111111110000000000
6362                                                                  10987654321098765432109876543210
6363                                                                  000001x0xx0x1000101xxxxxxxxxxxxx
6364                                                                  cls.  */
6365                                                               return 1314;
6366                                                             }
6367                                                         }
6368                                                       else
6369                                                         {
6370                                                           if (((word >> 19) & 0x1) == 0)
6371                                                             {
6372                                                               /* 33222222222211111111110000000000
6373                                                                  10987654321098765432109876543210
6374                                                                  000001x0xx0x0100101xxxxxxxxxxxxx
6375                                                                  sxtw.  */
6376                                                               return 1951;
6377                                                             }
6378                                                           else
6379                                                             {
6380                                                               /* 33222222222211111111110000000000
6381                                                                  10987654321098765432109876543210
6382                                                                  000001x0xx0x1100101xxxxxxxxxxxxx
6383                                                                  fabs.  */
6384                                                               return 1376;
6385                                                             }
6386                                                         }
6387                                                     }
6388                                                   else
6389                                                     {
6390                                                       if (((word >> 18) & 0x1) == 0)
6391                                                         {
6392                                                           if (((word >> 19) & 0x1) == 0)
6393                                                             {
6394                                                               /* 33222222222211111111110000000000
6395                                                                  10987654321098765432109876543210
6396                                                                  000001x0xx0x0010101xxxxxxxxxxxxx
6397                                                                  sxth.  */
6398                                                               return 1950;
6399                                                             }
6400                                                           else
6401                                                             {
6402                                                               /* 33222222222211111111110000000000
6403                                                                  10987654321098765432109876543210
6404                                                                  000001x0xx0x1010101xxxxxxxxxxxxx
6405                                                                  cnt.  */
6406                                                               return 1343;
6407                                                             }
6408                                                         }
6409                                                       else
6410                                                         {
6411                                                           if (((word >> 19) & 0x1) == 0)
6412                                                             {
6413                                                               /* 33222222222211111111110000000000
6414                                                                  10987654321098765432109876543210
6415                                                                  000001x0xx0x0110101xxxxxxxxxxxxx
6416                                                                  abs.  */
6417                                                               return 1272;
6418                                                             }
6419                                                           else
6420                                                             {
6421                                                               /* 33222222222211111111110000000000
6422                                                                  10987654321098765432109876543210
6423                                                                  000001x0xx0x1110101xxxxxxxxxxxxx
6424                                                                  not.  */
6425                                                               return 1750;
6426                                                             }
6427                                                         }
6428                                                     }
6429                                                 }
6430                                               else
6431                                                 {
6432                                                   if (((word >> 17) & 0x1) == 0)
6433                                                     {
6434                                                       if (((word >> 18) & 0x1) == 0)
6435                                                         {
6436                                                           if (((word >> 19) & 0x1) == 0)
6437                                                             {
6438                                                               /* 33222222222211111111110000000000
6439                                                                  10987654321098765432109876543210
6440                                                                  000001x0xx0x0001101xxxxxxxxxxxxx
6441                                                                  uxtb.  */
6442                                                               return 2012;
6443                                                             }
6444                                                           else
6445                                                             {
6446                                                               /* 33222222222211111111110000000000
6447                                                                  10987654321098765432109876543210
6448                                                                  000001x0xx0x1001101xxxxxxxxxxxxx
6449                                                                  clz.  */
6450                                                               return 1315;
6451                                                             }
6452                                                         }
6453                                                       else
6454                                                         {
6455                                                           if (((word >> 19) & 0x1) == 0)
6456                                                             {
6457                                                               /* 33222222222211111111110000000000
6458                                                                  10987654321098765432109876543210
6459                                                                  000001x0xx0x0101101xxxxxxxxxxxxx
6460                                                                  uxtw.  */
6461                                                               return 2014;
6462                                                             }
6463                                                           else
6464                                                             {
6465                                                               /* 33222222222211111111110000000000
6466                                                                  10987654321098765432109876543210
6467                                                                  000001x0xx0x1101101xxxxxxxxxxxxx
6468                                                                  fneg.  */
6469                                                               return 1453;
6470                                                             }
6471                                                         }
6472                                                     }
6473                                                   else
6474                                                     {
6475                                                       if (((word >> 18) & 0x1) == 0)
6476                                                         {
6477                                                           if (((word >> 19) & 0x1) == 0)
6478                                                             {
6479                                                               /* 33222222222211111111110000000000
6480                                                                  10987654321098765432109876543210
6481                                                                  000001x0xx0x0011101xxxxxxxxxxxxx
6482                                                                  uxth.  */
6483                                                               return 2013;
6484                                                             }
6485                                                           else
6486                                                             {
6487                                                               /* 33222222222211111111110000000000
6488                                                                  10987654321098765432109876543210
6489                                                                  000001x0xx0x1011101xxxxxxxxxxxxx
6490                                                                  cnot.  */
6491                                                               return 1342;
6492                                                             }
6493                                                         }
6494                                                       else
6495                                                         {
6496                                                           /* 33222222222211111111110000000000
6497                                                              10987654321098765432109876543210
6498                                                              000001x0xx0xx111101xxxxxxxxxxxxx
6499                                                              neg.  */
6500                                                           return 1747;
6501                                                         }
6502                                                     }
6503                                                 }
6504                                             }
6505                                           else
6506                                             {
6507                                               if (((word >> 12) & 0x1) == 0)
6508                                                 {
6509                                                   if (((word >> 23) & 0x1) == 0)
6510                                                     {
6511                                                       if (((word >> 22) & 0x1) == 0)
6512                                                         {
6513                                                           /* 33222222222211111111110000000000
6514                                                              10987654321098765432109876543210
6515                                                              000001x0001xxxxx1010xxxxxxxxxxxx
6516                                                              adr.  */
6517                                                           return 1278;
6518                                                         }
6519                                                       else
6520                                                         {
6521                                                           /* 33222222222211111111110000000000
6522                                                              10987654321098765432109876543210
6523                                                              000001x0011xxxxx1010xxxxxxxxxxxx
6524                                                              adr.  */
6525                                                           return 1279;
6526                                                         }
6527                                                     }
6528                                                   else
6529                                                     {
6530                                                       /* 33222222222211111111110000000000
6531                                                          10987654321098765432109876543210
6532                                                          000001x01x1xxxxx1010xxxxxxxxxxxx
6533                                                          adr.  */
6534                                                       return 1280;
6535                                                     }
6536                                                 }
6537                                               else
6538                                                 {
6539                                                   if (((word >> 10) & 0x1) == 0)
6540                                                     {
6541                                                       if (((word >> 11) & 0x1) == 0)
6542                                                         {
6543                                                           /* 33222222222211111111110000000000
6544                                                              10987654321098765432109876543210
6545                                                              000001x0xx1xxxxx101100xxxxxxxxxx
6546                                                              ftssel.  */
6547                                                           return 1479;
6548                                                         }
6549                                                       else
6550                                                         {
6551                                                           /* 33222222222211111111110000000000
6552                                                              10987654321098765432109876543210
6553                                                              000001x0xx1xxxxx101110xxxxxxxxxx
6554                                                              fexpa.  */
6555                                                           return 1423;
6556                                                         }
6557                                                     }
6558                                                   else
6559                                                     {
6560                                                       /* 33222222222211111111110000000000
6561                                                          10987654321098765432109876543210
6562                                                          000001x0xx1xxxxx1011x1xxxxxxxxxx
6563                                                          movprfx.  */
6564                                                       return 1740;
6565                                                     }
6566                                                 }
6567                                             }
6568                                         }
6569                                       else
6570                                         {
6571                                           if (((word >> 22) & 0x1) == 0)
6572                                             {
6573                                               if (((word >> 21) & 0x1) == 0)
6574                                                 {
6575                                                   if (((word >> 23) & 0x1) == 0)
6576                                                     {
6577                                                       /* 33222222222211111111110000000000
6578                                                          10987654321098765432109876543210
6579                                                          100001x0000xxxxx101xxxxxxxxxxxxx
6580                                                          ldnt1b.  */
6581                                                       return 2087;
6582                                                     }
6583                                                   else
6584                                                     {
6585                                                       /* 33222222222211111111110000000000
6586                                                          10987654321098765432109876543210
6587                                                          100001x0100xxxxx101xxxxxxxxxxxxx
6588                                                          ldnt1h.  */
6589                                                       return 2090;
6590                                                     }
6591                                                 }
6592                                               else
6593                                                 {
6594                                                   if (((word >> 23) & 0x1) == 0)
6595                                                     {
6596                                                       /* 33222222222211111111110000000000
6597                                                          10987654321098765432109876543210
6598                                                          100001x0001xxxxx101xxxxxxxxxxxxx
6599                                                          ldff1sb.  */
6600                                                       return 1666;
6601                                                     }
6602                                                   else
6603                                                     {
6604                                                       /* 33222222222211111111110000000000
6605                                                          10987654321098765432109876543210
6606                                                          100001x0101xxxxx101xxxxxxxxxxxxx
6607                                                          ldff1sh.  */
6608                                                       return 1678;
6609                                                     }
6610                                                 }
6611                                             }
6612                                           else
6613                                             {
6614                                               if (((word >> 23) & 0x1) == 0)
6615                                                 {
6616                                                   /* 33222222222211111111110000000000
6617                                                      10987654321098765432109876543210
6618                                                      100001x001xxxxxx101xxxxxxxxxxxxx
6619                                                      ld1rb.  */
6620                                                   return 1534;
6621                                                 }
6622                                               else
6623                                                 {
6624                                                   /* 33222222222211111111110000000000
6625                                                      10987654321098765432109876543210
6626                                                      100001x011xxxxxx101xxxxxxxxxxxxx
6627                                                      ld1rh.  */
6628                                                   return 1538;
6629                                                 }
6630                                             }
6631                                         }
6632                                     }
6633                                   else
6634                                     {
6635                                       if (((word >> 21) & 0x1) == 0)
6636                                         {
6637                                           if (((word >> 31) & 0x1) == 0)
6638                                             {
6639                                               if (((word >> 16) & 0x1) == 0)
6640                                                 {
6641                                                   if (((word >> 17) & 0x1) == 0)
6642                                                     {
6643                                                       if (((word >> 18) & 0x1) == 0)
6644                                                         {
6645                                                           if (((word >> 19) & 0x1) == 0)
6646                                                             {
6647                                                               /* 33222222222211111111110000000000
6648                                                                  10987654321098765432109876543210
6649                                                                  010001x0xx0x0000101xxxxxxxxxxxxx
6650                                                                  urecpe.  */
6651                                                               return 2298;
6652                                                             }
6653                                                           else
6654                                                             {
6655                                                               /* 33222222222211111111110000000000
6656                                                                  10987654321098765432109876543210
6657                                                                  010001x0xx0x1000101xxxxxxxxxxxxx
6658                                                                  sqabs.  */
6659                                                               return 2160;
6660                                                             }
6661                                                         }
6662                                                       else
6663                                                         {
6664                                                           if (((word >> 20) & 0x1) == 0)
6665                                                             {
6666                                                               /* 33222222222211111111110000000000
6667                                                                  10987654321098765432109876543210
6668                                                                  010001x0xx00x100101xxxxxxxxxxxxx
6669                                                                  sadalp.  */
6670                                                               return 2124;
6671                                                             }
6672                                                           else
6673                                                             {
6674                                                               /* 33222222222211111111110000000000
6675                                                                  10987654321098765432109876543210
6676                                                                  010001x0xx01x100101xxxxxxxxxxxxx
6677                                                                  smaxp.  */
6678                                                               return 2138;
6679                                                             }
6680                                                         }
6681                                                     }
6682                                                   else
6683                                                     {
6684                                                       /* 33222222222211111111110000000000
6685                                                          10987654321098765432109876543210
6686                                                          010001x0xx0xxx10101xxxxxxxxxxxxx
6687                                                          sminp.  */
6688                                                       return 2139;
6689                                                     }
6690                                                 }
6691                                               else
6692                                                 {
6693                                                   if (((word >> 17) & 0x1) == 0)
6694                                                     {
6695                                                       if (((word >> 18) & 0x1) == 0)
6696                                                         {
6697                                                           if (((word >> 19) & 0x1) == 0)
6698                                                             {
6699                                                               if (((word >> 20) & 0x1) == 0)
6700                                                                 {
6701                                                                   /* 33222222222211111111110000000000
6702                                                                      10987654321098765432109876543210
6703                                                                      010001x0xx000001101xxxxxxxxxxxxx
6704                                                                      ursqrte.  */
6705                                                                   return 2303;
6706                                                                 }
6707                                                               else
6708                                                                 {
6709                                                                   /* 33222222222211111111110000000000
6710                                                                      10987654321098765432109876543210
6711                                                                      010001x0xx010001101xxxxxxxxxxxxx
6712                                                                      addp.  */
6713                                                                   return 2049;
6714                                                                 }
6715                                                             }
6716                                                           else
6717                                                             {
6718                                                               /* 33222222222211111111110000000000
6719                                                                  10987654321098765432109876543210
6720                                                                  010001x0xx0x1001101xxxxxxxxxxxxx
6721                                                                  sqneg.  */
6722                                                               return 2187;
6723                                                             }
6724                                                         }
6725                                                       else
6726                                                         {
6727                                                           if (((word >> 20) & 0x1) == 0)
6728                                                             {
6729                                                               /* 33222222222211111111110000000000
6730                                                                  10987654321098765432109876543210
6731                                                                  010001x0xx00x101101xxxxxxxxxxxxx
6732                                                                  uadalp.  */
6733                                                               return 2255;
6734                                                             }
6735                                                           else
6736                                                             {
6737                                                               /* 33222222222211111111110000000000
6738                                                                  10987654321098765432109876543210
6739                                                                  010001x0xx01x101101xxxxxxxxxxxxx
6740                                                                  umaxp.  */
6741                                                               return 2263;
6742                                                             }
6743                                                         }
6744                                                     }
6745                                                   else
6746                                                     {
6747                                                       /* 33222222222211111111110000000000
6748                                                          10987654321098765432109876543210
6749                                                          010001x0xx0xxx11101xxxxxxxxxxxxx
6750                                                          uminp.  */
6751                                                       return 2264;
6752                                                     }
6753                                                 }
6754                                             }
6755                                           else
6756                                             {
6757                                               if (((word >> 23) & 0x1) == 0)
6758                                                 {
6759                                                   /* 33222222222211111111110000000000
6760                                                      10987654321098765432109876543210
6761                                                      110001x00x0xxxxx101xxxxxxxxxxxxx
6762                                                      ldff1sb.  */
6763                                                   return 1665;
6764                                                 }
6765                                               else
6766                                                 {
6767                                                   /* 33222222222211111111110000000000
6768                                                      10987654321098765432109876543210
6769                                                      110001x01x0xxxxx101xxxxxxxxxxxxx
6770                                                      ldff1sh.  */
6771                                                   return 1676;
6772                                                 }
6773                                             }
6774                                         }
6775                                       else
6776                                         {
6777                                           if (((word >> 22) & 0x1) == 0)
6778                                             {
6779                                               if (((word >> 23) & 0x1) == 0)
6780                                                 {
6781                                                   /* 33222222222211111111110000000000
6782                                                      10987654321098765432109876543210
6783                                                      x10001x0001xxxxx101xxxxxxxxxxxxx
6784                                                      ldff1sb.  */
6785                                                   return 1667;
6786                                                 }
6787                                               else
6788                                                 {
6789                                                   if (((word >> 31) & 0x1) == 0)
6790                                                     {
6791                                                       if (((word >> 10) & 0x1) == 0)
6792                                                         {
6793                                                           if (((word >> 12) & 0x1) == 0)
6794                                                             {
6795                                                               /* 33222222222211111111110000000000
6796                                                                  10987654321098765432109876543210
6797                                                                  010001x0101xxxxx1010x0xxxxxxxxxx
6798                                                                  smlslb.  */
6799                                                               return 2146;
6800                                                             }
6801                                                           else
6802                                                             {
6803                                                               /* 33222222222211111111110000000000
6804                                                                  10987654321098765432109876543210
6805                                                                  010001x0101xxxxx1011x0xxxxxxxxxx
6806                                                                  umlslb.  */
6807                                                               return 2271;
6808                                                             }
6809                                                         }
6810                                                       else
6811                                                         {
6812                                                           if (((word >> 12) & 0x1) == 0)
6813                                                             {
6814                                                               /* 33222222222211111111110000000000
6815                                                                  10987654321098765432109876543210
6816                                                                  010001x0101xxxxx1010x1xxxxxxxxxx
6817                                                                  smlslt.  */
6818                                                               return 2149;
6819                                                             }
6820                                                           else
6821                                                             {
6822                                                               /* 33222222222211111111110000000000
6823                                                                  10987654321098765432109876543210
6824                                                                  010001x0101xxxxx1011x1xxxxxxxxxx
6825                                                                  umlslt.  */
6826                                                               return 2274;
6827                                                             }
6828                                                         }
6829                                                     }
6830                                                   else
6831                                                     {
6832                                                       /* 33222222222211111111110000000000
6833                                                          10987654321098765432109876543210
6834                                                          110001x0101xxxxx101xxxxxxxxxxxxx
6835                                                          ldff1sh.  */
6836                                                       return 1679;
6837                                                     }
6838                                                 }
6839                                             }
6840                                           else
6841                                             {
6842                                               if (((word >> 23) & 0x1) == 0)
6843                                                 {
6844                                                   /* 33222222222211111111110000000000
6845                                                      10987654321098765432109876543210
6846                                                      x10001x0011xxxxx101xxxxxxxxxxxxx
6847                                                      prfh.  */
6848                                                   return 1779;
6849                                                 }
6850                                               else
6851                                                 {
6852                                                   if (((word >> 31) & 0x1) == 0)
6853                                                     {
6854                                                       if (((word >> 10) & 0x1) == 0)
6855                                                         {
6856                                                           if (((word >> 12) & 0x1) == 0)
6857                                                             {
6858                                                               /* 33222222222211111111110000000000
6859                                                                  10987654321098765432109876543210
6860                                                                  010001x0111xxxxx1010x0xxxxxxxxxx
6861                                                                  smlslb.  */
6862                                                               return 2147;
6863                                                             }
6864                                                           else
6865                                                             {
6866                                                               /* 33222222222211111111110000000000
6867                                                                  10987654321098765432109876543210
6868                                                                  010001x0111xxxxx1011x0xxxxxxxxxx
6869                                                                  umlslb.  */
6870                                                               return 2272;
6871                                                             }
6872                                                         }
6873                                                       else
6874                                                         {
6875                                                           if (((word >> 12) & 0x1) == 0)
6876                                                             {
6877                                                               /* 33222222222211111111110000000000
6878                                                                  10987654321098765432109876543210
6879                                                                  010001x0111xxxxx1010x1xxxxxxxxxx
6880                                                                  smlslt.  */
6881                                                               return 2150;
6882                                                             }
6883                                                           else
6884                                                             {
6885                                                               /* 33222222222211111111110000000000
6886                                                                  10987654321098765432109876543210
6887                                                                  010001x0111xxxxx1011x1xxxxxxxxxx
6888                                                                  umlslt.  */
6889                                                               return 2275;
6890                                                             }
6891                                                         }
6892                                                     }
6893                                                   else
6894                                                     {
6895                                                       /* 33222222222211111111110000000000
6896                                                          10987654321098765432109876543210
6897                                                          110001x0111xxxxx101xxxxxxxxxxxxx
6898                                                          ldff1sh.  */
6899                                                       return 1677;
6900                                                     }
6901                                                 }
6902                                             }
6903                                         }
6904                                     }
6905                                 }
6906                             }
6907                           else
6908                             {
6909                               if (((word >> 15) & 0x1) == 0)
6910                                 {
6911                                   if (((word >> 21) & 0x1) == 0)
6912                                     {
6913                                       if (((word >> 30) & 0x1) == 0)
6914                                         {
6915                                           if (((word >> 31) & 0x1) == 0)
6916                                             {
6917                                               /* 33222222222211111111110000000000
6918                                                  10987654321098765432109876543210
6919                                                  000001x0xx0xxxxx011xxxxxxxxxxxxx
6920                                                  mls.  */
6921                                               return 1739;
6922                                             }
6923                                           else
6924                                             {
6925                                               if (((word >> 23) & 0x1) == 0)
6926                                                 {
6927                                                   /* 33222222222211111111110000000000
6928                                                      10987654321098765432109876543210
6929                                                      100001x00x0xxxxx011xxxxxxxxxxxxx
6930                                                      ldff1b.  */
6931                                                   return 1623;
6932                                                 }
6933                                               else
6934                                                 {
6935                                                   /* 33222222222211111111110000000000
6936                                                      10987654321098765432109876543210
6937                                                      100001x01x0xxxxx011xxxxxxxxxxxxx
6938                                                      ldff1h.  */
6939                                                   return 1643;
6940                                                 }
6941                                             }
6942                                         }
6943                                       else
6944                                         {
6945                                           if (((word >> 31) & 0x1) == 0)
6946                                             {
6947                                               if (((word >> 10) & 0x1) == 0)
6948                                                 {
6949                                                   if (((word >> 11) & 0x1) == 0)
6950                                                     {
6951                                                       if (((word >> 12) & 0x1) == 0)
6952                                                         {
6953                                                           /* 33222222222211111111110000000000
6954                                                              10987654321098765432109876543210
6955                                                              010001x0xx0xxxxx011000xxxxxxxxxx
6956                                                              sqdmlalb.  */
6957                                                           return 2165;
6958                                                         }
6959                                                       else
6960                                                         {
6961                                                           /* 33222222222211111111110000000000
6962                                                              10987654321098765432109876543210
6963                                                              010001x0xx0xxxxx011100xxxxxxxxxx
6964                                                              sqrdmlah.  */
6965                                                           return 2194;
6966                                                         }
6967                                                     }
6968                                                   else
6969                                                     {
6970                                                       /* 33222222222211111111110000000000
6971                                                          10987654321098765432109876543210
6972                                                          010001x0xx0xxxxx011x10xxxxxxxxxx
6973                                                          sqdmlslb.  */
6974                                                       return 2172;
6975                                                     }
6976                                                 }
6977                                               else
6978                                                 {
6979                                                   if (((word >> 11) & 0x1) == 0)
6980                                                     {
6981                                                       if (((word >> 12) & 0x1) == 0)
6982                                                         {
6983                                                           /* 33222222222211111111110000000000
6984                                                              10987654321098765432109876543210
6985                                                              010001x0xx0xxxxx011001xxxxxxxxxx
6986                                                              sqdmlalt.  */
6987                                                           return 2169;
6988                                                         }
6989                                                       else
6990                                                         {
6991                                                           /* 33222222222211111111110000000000
6992                                                              10987654321098765432109876543210
6993                                                              010001x0xx0xxxxx011101xxxxxxxxxx
6994                                                              sqrdmlsh.  */
6995                                                           return 2198;
6996                                                         }
6997                                                     }
6998                                                   else
6999                                                     {
7000                                                       /* 33222222222211111111110000000000
7001                                                          10987654321098765432109876543210
7002                                                          010001x0xx0xxxxx011x11xxxxxxxxxx
7003                                                          sqdmlslt.  */
7004                                                       return 2176;
7005                                                     }
7006                                                 }
7007                                             }
7008                                           else
7009                                             {
7010                                               if (((word >> 23) & 0x1) == 0)
7011                                                 {
7012                                                   /* 33222222222211111111110000000000
7013                                                      10987654321098765432109876543210
7014                                                      110001x00x0xxxxx011xxxxxxxxxxxxx
7015                                                      ldff1b.  */
7016                                                   return 1632;
7017                                                 }
7018                                               else
7019                                                 {
7020                                                   /* 33222222222211111111110000000000
7021                                                      10987654321098765432109876543210
7022                                                      110001x01x0xxxxx011xxxxxxxxxxxxx
7023                                                      ldff1h.  */
7024                                                   return 1651;
7025                                                 }
7026                                             }
7027                                         }
7028                                     }
7029                                   else
7030                                     {
7031                                       if (((word >> 30) & 0x1) == 0)
7032                                         {
7033                                           if (((word >> 31) & 0x1) == 0)
7034                                             {
7035                                               if (((word >> 10) & 0x1) == 0)
7036                                                 {
7037                                                   if (((word >> 11) & 0x1) == 0)
7038                                                     {
7039                                                       if (((word >> 12) & 0x1) == 0)
7040                                                         {
7041                                                           /* 33222222222211111111110000000000
7042                                                              10987654321098765432109876543210
7043                                                              000001x0xx1xxxxx011000xxxxxxxxxx
7044                                                              mul.  */
7045                                                           return 2107;
7046                                                         }
7047                                                       else
7048                                                         {
7049                                                           /* 33222222222211111111110000000000
7050                                                              10987654321098765432109876543210
7051                                                              000001x0xx1xxxxx011100xxxxxxxxxx
7052                                                              sqdmulh.  */
7053                                                           return 2180;
7054                                                         }
7055                                                     }
7056                                                   else
7057                                                     {
7058                                                       /* 33222222222211111111110000000000
7059                                                          10987654321098765432109876543210
7060                                                          000001x0xx1xxxxx011x10xxxxxxxxxx
7061                                                          smulh.  */
7062                                                       return 2152;
7063                                                     }
7064                                                 }
7065                                               else
7066                                                 {
7067                                                   if (((word >> 11) & 0x1) == 0)
7068                                                     {
7069                                                       if (((word >> 12) & 0x1) == 0)
7070                                                         {
7071                                                           /* 33222222222211111111110000000000
7072                                                              10987654321098765432109876543210
7073                                                              000001x0xx1xxxxx011001xxxxxxxxxx
7074                                                              pmul.  */
7075                                                           return 2110;
7076                                                         }
7077                                                       else
7078                                                         {
7079                                                           /* 33222222222211111111110000000000
7080                                                              10987654321098765432109876543210
7081                                                              000001x0xx1xxxxx011101xxxxxxxxxx
7082                                                              sqrdmulh.  */
7083                                                           return 2202;
7084                                                         }
7085                                                     }
7086                                                   else
7087                                                     {
7088                                                       /* 33222222222211111111110000000000
7089                                                          10987654321098765432109876543210
7090                                                          000001x0xx1xxxxx011x11xxxxxxxxxx
7091                                                          umulh.  */
7092                                                       return 2277;
7093                                                     }
7094                                                 }
7095                                             }
7096                                           else
7097                                             {
7098                                               if (((word >> 23) & 0x1) == 0)
7099                                                 {
7100                                                   /* 33222222222211111111110000000000
7101                                                      10987654321098765432109876543210
7102                                                      100001x00x1xxxxx011xxxxxxxxxxxxx
7103                                                      prfd.  */
7104                                                   return 1769;
7105                                                 }
7106                                               else
7107                                                 {
7108                                                   /* 33222222222211111111110000000000
7109                                                      10987654321098765432109876543210
7110                                                      100001x01x1xxxxx011xxxxxxxxxxxxx
7111                                                      ldff1h.  */
7112                                                   return 1644;
7113                                                 }
7114                                             }
7115                                         }
7116                                       else
7117                                         {
7118                                           if (((word >> 23) & 0x1) == 0)
7119                                             {
7120                                               /* 33222222222211111111110000000000
7121                                                  10987654321098765432109876543210
7122                                                  x10001x00x1xxxxx011xxxxxxxxxxxxx
7123                                                  prfd.  */
7124                                               return 1771;
7125                                             }
7126                                           else
7127                                             {
7128                                               if (((word >> 31) & 0x1) == 0)
7129                                                 {
7130                                                   if (((word >> 12) & 0x1) == 0)
7131                                                     {
7132                                                       if (((word >> 22) & 0x1) == 0)
7133                                                         {
7134                                                           /* 33222222222211111111110000000000
7135                                                              10987654321098765432109876543210
7136                                                              010001x0101xxxxx0110xxxxxxxxxxxx
7137                                                              cmla.  */
7138                                                           return 2059;
7139                                                         }
7140                                                       else
7141                                                         {
7142                                                           /* 33222222222211111111110000000000
7143                                                              10987654321098765432109876543210
7144                                                              010001x0111xxxxx0110xxxxxxxxxxxx
7145                                                              cmla.  */
7146                                                           return 2060;
7147                                                         }
7148                                                     }
7149                                                   else
7150                                                     {
7151                                                       if (((word >> 22) & 0x1) == 0)
7152                                                         {
7153                                                           /* 33222222222211111111110000000000
7154                                                              10987654321098765432109876543210
7155                                                              010001x0101xxxxx0111xxxxxxxxxxxx
7156                                                              sqrdcmlah.  */
7157                                                           return 2188;
7158                                                         }
7159                                                       else
7160                                                         {
7161                                                           /* 33222222222211111111110000000000
7162                                                              10987654321098765432109876543210
7163                                                              010001x0111xxxxx0111xxxxxxxxxxxx
7164                                                              sqrdcmlah.  */
7165                                                           return 2189;
7166                                                         }
7167                                                     }
7168                                                 }
7169                                               else
7170                                                 {
7171                                                   /* 33222222222211111111110000000000
7172                                                      10987654321098765432109876543210
7173                                                      110001x01x1xxxxx011xxxxxxxxxxxxx
7174                                                      ldff1h.  */
7175                                                   return 1652;
7176                                                 }
7177                                             }
7178                                         }
7179                                     }
7180                                 }
7181                               else
7182                                 {
7183                                   if (((word >> 30) & 0x1) == 0)
7184                                     {
7185                                       if (((word >> 31) & 0x1) == 0)
7186                                         {
7187                                           if (((word >> 21) & 0x1) == 0)
7188                                             {
7189                                               /* 33222222222211111111110000000000
7190                                                  10987654321098765432109876543210
7191                                                  000001x0xx0xxxxx111xxxxxxxxxxxxx
7192                                                  msb.  */
7193                                               return 1742;
7194                                             }
7195                                           else
7196                                             {
7197                                               if (((word >> 10) & 0x1) == 0)
7198                                                 {
7199                                                   if (((word >> 11) & 0x1) == 0)
7200                                                     {
7201                                                       if (((word >> 12) & 0x1) == 0)
7202                                                         {
7203                                                           if (((word >> 20) & 0x1) == 0)
7204                                                             {
7205                                                               if (((word >> 22) & 0x1) == 0)
7206                                                                 {
7207                                                                   if (((word >> 23) & 0x1) == 0)
7208                                                                     {
7209                                                                       /* 33222222222211111111110000000000
7210                                                                          10987654321098765432109876543210
7211                                                                          000001x00010xxxx111000xxxxxxxxxx
7212                                                                          cntb.  */
7213                                                                       return 1344;
7214                                                                     }
7215                                                                   else
7216                                                                     {
7217                                                                       /* 33222222222211111111110000000000
7218                                                                          10987654321098765432109876543210
7219                                                                          000001x01010xxxx111000xxxxxxxxxx
7220                                                                          cntw.  */
7221                                                                       return 1348;
7222                                                                     }
7223                                                                 }
7224                                                               else
7225                                                                 {
7226                                                                   if (((word >> 23) & 0x1) == 0)
7227                                                                     {
7228                                                                       /* 33222222222211111111110000000000
7229                                                                          10987654321098765432109876543210
7230                                                                          000001x00110xxxx111000xxxxxxxxxx
7231                                                                          cnth.  */
7232                                                                       return 1346;
7233                                                                     }
7234                                                                   else
7235                                                                     {
7236                                                                       /* 33222222222211111111110000000000
7237                                                                          10987654321098765432109876543210
7238                                                                          000001x01110xxxx111000xxxxxxxxxx
7239                                                                          cntd.  */
7240                                                                       return 1345;
7241                                                                     }
7242                                                                 }
7243                                                             }
7244                                                           else
7245                                                             {
7246                                                               if (((word >> 22) & 0x1) == 0)
7247                                                                 {
7248                                                                   if (((word >> 23) & 0x1) == 0)
7249                                                                     {
7250                                                                       /* 33222222222211111111110000000000
7251                                                                          10987654321098765432109876543210
7252                                                                          000001x00011xxxx111000xxxxxxxxxx
7253                                                                          incb.  */
7254                                                                       return 1480;
7255                                                                     }
7256                                                                   else
7257                                                                     {
7258                                                                       /* 33222222222211111111110000000000
7259                                                                          10987654321098765432109876543210
7260                                                                          000001x01011xxxx111000xxxxxxxxxx
7261                                                                          incw.  */
7262                                                                       return 1488;
7263                                                                     }
7264                                                                 }
7265                                                               else
7266                                                                 {
7267                                                                   if (((word >> 23) & 0x1) == 0)
7268                                                                     {
7269                                                                       /* 33222222222211111111110000000000
7270                                                                          10987654321098765432109876543210
7271                                                                          000001x00111xxxx111000xxxxxxxxxx
7272                                                                          inch.  */
7273                                                                       return 1484;
7274                                                                     }
7275                                                                   else
7276                                                                     {
7277                                                                       /* 33222222222211111111110000000000
7278                                                                          10987654321098765432109876543210
7279                                                                          000001x01111xxxx111000xxxxxxxxxx
7280                                                                          incd.  */
7281                                                                       return 1482;
7282                                                                     }
7283                                                                 }
7284                                                             }
7285                                                         }
7286                                                       else
7287                                                         {
7288                                                           if (((word >> 20) & 0x1) == 0)
7289                                                             {
7290                                                               if (((word >> 22) & 0x1) == 0)
7291                                                                 {
7292                                                                   if (((word >> 23) & 0x1) == 0)
7293                                                                     {
7294                                                                       /* 33222222222211111111110000000000
7295                                                                          10987654321098765432109876543210
7296                                                                          000001x00010xxxx111100xxxxxxxxxx
7297                                                                          sqincb.  */
7298                                                                       return 1847;
7299                                                                     }
7300                                                                   else
7301                                                                     {
7302                                                                       /* 33222222222211111111110000000000
7303                                                                          10987654321098765432109876543210
7304                                                                          000001x01010xxxx111100xxxxxxxxxx
7305                                                                          sqincw.  */
7306                                                                       return 1859;
7307                                                                     }
7308                                                                 }
7309                                                               else
7310                                                                 {
7311                                                                   if (((word >> 23) & 0x1) == 0)
7312                                                                     {
7313                                                                       /* 33222222222211111111110000000000
7314                                                                          10987654321098765432109876543210
7315                                                                          000001x00110xxxx111100xxxxxxxxxx
7316                                                                          sqinch.  */
7317                                                                       return 1853;
7318                                                                     }
7319                                                                   else
7320                                                                     {
7321                                                                       /* 33222222222211111111110000000000
7322                                                                          10987654321098765432109876543210
7323                                                                          000001x01110xxxx111100xxxxxxxxxx
7324                                                                          sqincd.  */
7325                                                                       return 1850;
7326                                                                     }
7327                                                                 }
7328                                                             }
7329                                                           else
7330                                                             {
7331                                                               if (((word >> 22) & 0x1) == 0)
7332                                                                 {
7333                                                                   if (((word >> 23) & 0x1) == 0)
7334                                                                     {
7335                                                                       /* 33222222222211111111110000000000
7336                                                                          10987654321098765432109876543210
7337                                                                          000001x00011xxxx111100xxxxxxxxxx
7338                                                                          sqincb.  */
7339                                                                       return 1846;
7340                                                                     }
7341                                                                   else
7342                                                                     {
7343                                                                       /* 33222222222211111111110000000000
7344                                                                          10987654321098765432109876543210
7345                                                                          000001x01011xxxx111100xxxxxxxxxx
7346                                                                          sqincw.  */
7347                                                                       return 1858;
7348                                                                     }
7349                                                                 }
7350                                                               else
7351                                                                 {
7352                                                                   if (((word >> 23) & 0x1) == 0)
7353                                                                     {
7354                                                                       /* 33222222222211111111110000000000
7355                                                                          10987654321098765432109876543210
7356                                                                          000001x00111xxxx111100xxxxxxxxxx
7357                                                                          sqinch.  */
7358                                                                       return 1852;
7359                                                                     }
7360                                                                   else
7361                                                                     {
7362                                                                       /* 33222222222211111111110000000000
7363                                                                          10987654321098765432109876543210
7364                                                                          000001x01111xxxx111100xxxxxxxxxx
7365                                                                          sqincd.  */
7366                                                                       return 1849;
7367                                                                     }
7368                                                                 }
7369                                                             }
7370                                                         }
7371                                                     }
7372                                                   else
7373                                                     {
7374                                                       if (((word >> 20) & 0x1) == 0)
7375                                                         {
7376                                                           if (((word >> 22) & 0x1) == 0)
7377                                                             {
7378                                                               if (((word >> 23) & 0x1) == 0)
7379                                                                 {
7380                                                                   /* 33222222222211111111110000000000
7381                                                                      10987654321098765432109876543210
7382                                                                      000001x00010xxxx111x10xxxxxxxxxx
7383                                                                      sqdecb.  */
7384                                                                   return 1833;
7385                                                                 }
7386                                                               else
7387                                                                 {
7388                                                                   /* 33222222222211111111110000000000
7389                                                                      10987654321098765432109876543210
7390                                                                      000001x01010xxxx111x10xxxxxxxxxx
7391                                                                      sqdecw.  */
7392                                                                   return 1845;
7393                                                                 }
7394                                                             }
7395                                                           else
7396                                                             {
7397                                                               if (((word >> 23) & 0x1) == 0)
7398                                                                 {
7399                                                                   /* 33222222222211111111110000000000
7400                                                                      10987654321098765432109876543210
7401                                                                      000001x00110xxxx111x10xxxxxxxxxx
7402                                                                      sqdech.  */
7403                                                                   return 1839;
7404                                                                 }
7405                                                               else
7406                                                                 {
7407                                                                   /* 33222222222211111111110000000000
7408                                                                      10987654321098765432109876543210
7409                                                                      000001x01110xxxx111x10xxxxxxxxxx
7410                                                                      sqdecd.  */
7411                                                                   return 1836;
7412                                                                 }
7413                                                             }
7414                                                         }
7415                                                       else
7416                                                         {
7417                                                           if (((word >> 22) & 0x1) == 0)
7418                                                             {
7419                                                               if (((word >> 23) & 0x1) == 0)
7420                                                                 {
7421                                                                   /* 33222222222211111111110000000000
7422                                                                      10987654321098765432109876543210
7423                                                                      000001x00011xxxx111x10xxxxxxxxxx
7424                                                                      sqdecb.  */
7425                                                                   return 1832;
7426                                                                 }
7427                                                               else
7428                                                                 {
7429                                                                   /* 33222222222211111111110000000000
7430                                                                      10987654321098765432109876543210
7431                                                                      000001x01011xxxx111x10xxxxxxxxxx
7432                                                                      sqdecw.  */
7433                                                                   return 1844;
7434                                                                 }
7435                                                             }
7436                                                           else
7437                                                             {
7438                                                               if (((word >> 23) & 0x1) == 0)
7439                                                                 {
7440                                                                   /* 33222222222211111111110000000000
7441                                                                      10987654321098765432109876543210
7442                                                                      000001x00111xxxx111x10xxxxxxxxxx
7443                                                                      sqdech.  */
7444                                                                   return 1838;
7445                                                                 }
7446                                                               else
7447                                                                 {
7448                                                                   /* 33222222222211111111110000000000
7449                                                                      10987654321098765432109876543210
7450                                                                      000001x01111xxxx111x10xxxxxxxxxx
7451                                                                      sqdecd.  */
7452                                                                   return 1835;
7453                                                                 }
7454                                                             }
7455                                                         }
7456                                                     }
7457                                                 }
7458                                               else
7459                                                 {
7460                                                   if (((word >> 11) & 0x1) == 0)
7461                                                     {
7462                                                       if (((word >> 12) & 0x1) == 0)
7463                                                         {
7464                                                           if (((word >> 22) & 0x1) == 0)
7465                                                             {
7466                                                               if (((word >> 23) & 0x1) == 0)
7467                                                                 {
7468                                                                   /* 33222222222211111111110000000000
7469                                                                      10987654321098765432109876543210
7470                                                                      000001x0001xxxxx111001xxxxxxxxxx
7471                                                                      decb.  */
7472                                                                   return 1355;
7473                                                                 }
7474                                                               else
7475                                                                 {
7476                                                                   /* 33222222222211111111110000000000
7477                                                                      10987654321098765432109876543210
7478                                                                      000001x0101xxxxx111001xxxxxxxxxx
7479                                                                      decw.  */
7480                                                                   return 1363;
7481                                                                 }
7482                                                             }
7483                                                           else
7484                                                             {
7485                                                               if (((word >> 23) & 0x1) == 0)
7486                                                                 {
7487                                                                   /* 33222222222211111111110000000000
7488                                                                      10987654321098765432109876543210
7489                                                                      000001x0011xxxxx111001xxxxxxxxxx
7490                                                                      dech.  */
7491                                                                   return 1359;
7492                                                                 }
7493                                                               else
7494                                                                 {
7495                                                                   /* 33222222222211111111110000000000
7496                                                                      10987654321098765432109876543210
7497                                                                      000001x0111xxxxx111001xxxxxxxxxx
7498                                                                      decd.  */
7499                                                                   return 1357;
7500                                                                 }
7501                                                             }
7502                                                         }
7503                                                       else
7504                                                         {
7505                                                           if (((word >> 20) & 0x1) == 0)
7506                                                             {
7507                                                               if (((word >> 22) & 0x1) == 0)
7508                                                                 {
7509                                                                   if (((word >> 23) & 0x1) == 0)
7510                                                                     {
7511                                                                       /* 33222222222211111111110000000000
7512                                                                          10987654321098765432109876543210
7513                                                                          000001x00010xxxx111101xxxxxxxxxx
7514                                                                          uqincb.  */
7515                                                                       return 1994;
7516                                                                     }
7517                                                                   else
7518                                                                     {
7519                                                                       /* 33222222222211111111110000000000
7520                                                                          10987654321098765432109876543210
7521                                                                          000001x01010xxxx111101xxxxxxxxxx
7522                                                                          uqincw.  */
7523                                                                       return 2006;
7524                                                                     }
7525                                                                 }
7526                                                               else
7527                                                                 {
7528                                                                   if (((word >> 23) & 0x1) == 0)
7529                                                                     {
7530                                                                       /* 33222222222211111111110000000000
7531                                                                          10987654321098765432109876543210
7532                                                                          000001x00110xxxx111101xxxxxxxxxx
7533                                                                          uqinch.  */
7534                                                                       return 2000;
7535                                                                     }
7536                                                                   else
7537                                                                     {
7538                                                                       /* 33222222222211111111110000000000
7539                                                                          10987654321098765432109876543210
7540                                                                          000001x01110xxxx111101xxxxxxxxxx
7541                                                                          uqincd.  */
7542                                                                       return 1997;
7543                                                                     }
7544                                                                 }
7545                                                             }
7546                                                           else
7547                                                             {
7548                                                               if (((word >> 22) & 0x1) == 0)
7549                                                                 {
7550                                                                   if (((word >> 23) & 0x1) == 0)
7551                                                                     {
7552                                                                       /* 33222222222211111111110000000000
7553                                                                          10987654321098765432109876543210
7554                                                                          000001x00011xxxx111101xxxxxxxxxx
7555                                                                          uqincb.  */
7556                                                                       return 1995;
7557                                                                     }
7558                                                                   else
7559                                                                     {
7560                                                                       /* 33222222222211111111110000000000
7561                                                                          10987654321098765432109876543210
7562                                                                          000001x01011xxxx111101xxxxxxxxxx
7563                                                                          uqincw.  */
7564                                                                       return 2007;
7565                                                                     }
7566                                                                 }
7567                                                               else
7568                                                                 {
7569                                                                   if (((word >> 23) & 0x1) == 0)
7570                                                                     {
7571                                                                       /* 33222222222211111111110000000000
7572                                                                          10987654321098765432109876543210
7573                                                                          000001x00111xxxx111101xxxxxxxxxx
7574                                                                          uqinch.  */
7575                                                                       return 2001;
7576                                                                     }
7577                                                                   else
7578                                                                     {
7579                                                                       /* 33222222222211111111110000000000
7580                                                                          10987654321098765432109876543210
7581                                                                          000001x01111xxxx111101xxxxxxxxxx
7582                                                                          uqincd.  */
7583                                                                       return 1998;
7584                                                                     }
7585                                                                 }
7586                                                             }
7587                                                         }
7588                                                     }
7589                                                   else
7590                                                     {
7591                                                       if (((word >> 20) & 0x1) == 0)
7592                                                         {
7593                                                           if (((word >> 22) & 0x1) == 0)
7594                                                             {
7595                                                               if (((word >> 23) & 0x1) == 0)
7596                                                                 {
7597                                                                   /* 33222222222211111111110000000000
7598                                                                      10987654321098765432109876543210
7599                                                                      000001x00010xxxx111x11xxxxxxxxxx
7600                                                                      uqdecb.  */
7601                                                                   return 1980;
7602                                                                 }
7603                                                               else
7604                                                                 {
7605                                                                   /* 33222222222211111111110000000000
7606                                                                      10987654321098765432109876543210
7607                                                                      000001x01010xxxx111x11xxxxxxxxxx
7608                                                                      uqdecw.  */
7609                                                                   return 1992;
7610                                                                 }
7611                                                             }
7612                                                           else
7613                                                             {
7614                                                               if (((word >> 23) & 0x1) == 0)
7615                                                                 {
7616                                                                   /* 33222222222211111111110000000000
7617                                                                      10987654321098765432109876543210
7618                                                                      000001x00110xxxx111x11xxxxxxxxxx
7619                                                                      uqdech.  */
7620                                                                   return 1986;
7621                                                                 }
7622                                                               else
7623                                                                 {
7624                                                                   /* 33222222222211111111110000000000
7625                                                                      10987654321098765432109876543210
7626                                                                      000001x01110xxxx111x11xxxxxxxxxx
7627                                                                      uqdecd.  */
7628                                                                   return 1983;
7629                                                                 }
7630                                                             }
7631                                                         }
7632                                                       else
7633                                                         {
7634                                                           if (((word >> 22) & 0x1) == 0)
7635                                                             {
7636                                                               if (((word >> 23) & 0x1) == 0)
7637                                                                 {
7638                                                                   /* 33222222222211111111110000000000
7639                                                                      10987654321098765432109876543210
7640                                                                      000001x00011xxxx111x11xxxxxxxxxx
7641                                                                      uqdecb.  */
7642                                                                   return 1981;
7643                                                                 }
7644                                                               else
7645                                                                 {
7646                                                                   /* 33222222222211111111110000000000
7647                                                                      10987654321098765432109876543210
7648                                                                      000001x01011xxxx111x11xxxxxxxxxx
7649                                                                      uqdecw.  */
7650                                                                   return 1993;
7651                                                                 }
7652                                                             }
7653                                                           else
7654                                                             {
7655                                                               if (((word >> 23) & 0x1) == 0)
7656                                                                 {
7657                                                                   /* 33222222222211111111110000000000
7658                                                                      10987654321098765432109876543210
7659                                                                      000001x00111xxxx111x11xxxxxxxxxx
7660                                                                      uqdech.  */
7661                                                                   return 1987;
7662                                                                 }
7663                                                               else
7664                                                                 {
7665                                                                   /* 33222222222211111111110000000000
7666                                                                      10987654321098765432109876543210
7667                                                                      000001x01111xxxx111x11xxxxxxxxxx
7668                                                                      uqdecd.  */
7669                                                                   return 1984;
7670                                                                 }
7671                                                             }
7672                                                         }
7673                                                     }
7674                                                 }
7675                                             }
7676                                         }
7677                                       else
7678                                         {
7679                                           if (((word >> 22) & 0x1) == 0)
7680                                             {
7681                                               if (((word >> 21) & 0x1) == 0)
7682                                                 {
7683                                                   if (((word >> 23) & 0x1) == 0)
7684                                                     {
7685                                                       /* 33222222222211111111110000000000
7686                                                          10987654321098765432109876543210
7687                                                          100001x0000xxxxx111xxxxxxxxxxxxx
7688                                                          prfb.  */
7689                                                       return 1766;
7690                                                     }
7691                                                   else
7692                                                     {
7693                                                       /* 33222222222211111111110000000000
7694                                                          10987654321098765432109876543210
7695                                                          100001x0100xxxxx111xxxxxxxxxxxxx
7696                                                          prfh.  */
7697                                                       return 1780;
7698                                                     }
7699                                                 }
7700                                               else
7701                                                 {
7702                                                   if (((word >> 23) & 0x1) == 0)
7703                                                     {
7704                                                       /* 33222222222211111111110000000000
7705                                                          10987654321098765432109876543210
7706                                                          100001x0001xxxxx111xxxxxxxxxxxxx
7707                                                          ldff1b.  */
7708                                                       return 1634;
7709                                                     }
7710                                                   else
7711                                                     {
7712                                                       /* 33222222222211111111110000000000
7713                                                          10987654321098765432109876543210
7714                                                          100001x0101xxxxx111xxxxxxxxxxxxx
7715                                                          ldff1h.  */
7716                                                       return 1655;
7717                                                     }
7718                                                 }
7719                                             }
7720                                           else
7721                                             {
7722                                               if (((word >> 23) & 0x1) == 0)
7723                                                 {
7724                                                   /* 33222222222211111111110000000000
7725                                                      10987654321098765432109876543210
7726                                                      100001x001xxxxxx111xxxxxxxxxxxxx
7727                                                      ld1rb.  */
7728                                                   return 1536;
7729                                                 }
7730                                               else
7731                                                 {
7732                                                   /* 33222222222211111111110000000000
7733                                                      10987654321098765432109876543210
7734                                                      100001x011xxxxxx111xxxxxxxxxxxxx
7735                                                      ld1rh.  */
7736                                                   return 1540;
7737                                                 }
7738                                             }
7739                                         }
7740                                     }
7741                                   else
7742                                     {
7743                                       if (((word >> 21) & 0x1) == 0)
7744                                         {
7745                                           if (((word >> 22) & 0x1) == 0)
7746                                             {
7747                                               if (((word >> 23) & 0x1) == 0)
7748                                                 {
7749                                                   /* 33222222222211111111110000000000
7750                                                      10987654321098765432109876543210
7751                                                      x10001x0000xxxxx111xxxxxxxxxxxxx
7752                                                      prfb.  */
7753                                                   return 1768;
7754                                                 }
7755                                               else
7756                                                 {
7757                                                   /* 33222222222211111111110000000000
7758                                                      10987654321098765432109876543210
7759                                                      x10001x0100xxxxx111xxxxxxxxxxxxx
7760                                                      prfh.  */
7761                                                   return 1782;
7762                                                 }
7763                                             }
7764                                           else
7765                                             {
7766                                               if (((word >> 23) & 0x1) == 0)
7767                                                 {
7768                                                   /* 33222222222211111111110000000000
7769                                                      10987654321098765432109876543210
7770                                                      x10001x0010xxxxx111xxxxxxxxxxxxx
7771                                                      ldff1b.  */
7772                                                   return 1633;
7773                                                 }
7774                                               else
7775                                                 {
7776                                                   /* 33222222222211111111110000000000
7777                                                      10987654321098765432109876543210
7778                                                      x10001x0110xxxxx111xxxxxxxxxxxxx
7779                                                      ldff1h.  */
7780                                                   return 1653;
7781                                                 }
7782                                             }
7783                                         }
7784                                       else
7785                                         {
7786                                           if (((word >> 23) & 0x1) == 0)
7787                                             {
7788                                               if (((word >> 31) & 0x1) == 0)
7789                                                 {
7790                                                   if (((word >> 10) & 0x1) == 0)
7791                                                     {
7792                                                       if (((word >> 11) & 0x1) == 0)
7793                                                         {
7794                                                           /* 33222222222211111111110000000000
7795                                                              10987654321098765432109876543210
7796                                                              010001x00x1xxxxx111x00xxxxxxxxxx
7797                                                              sqdmulh.  */
7798                                                           return 2177;
7799                                                         }
7800                                                       else
7801                                                         {
7802                                                           /* 33222222222211111111110000000000
7803                                                              10987654321098765432109876543210
7804                                                              010001x00x1xxxxx111x10xxxxxxxxxx
7805                                                              mul.  */
7806                                                           return 2104;
7807                                                         }
7808                                                     }
7809                                                   else
7810                                                     {
7811                                                       /* 33222222222211111111110000000000
7812                                                          10987654321098765432109876543210
7813                                                          010001x00x1xxxxx111xx1xxxxxxxxxx
7814                                                          sqrdmulh.  */
7815                                                       return 2199;
7816                                                     }
7817                                                 }
7818                                               else
7819                                                 {
7820                                                   if (((word >> 22) & 0x1) == 0)
7821                                                     {
7822                                                       /* 33222222222211111111110000000000
7823                                                          10987654321098765432109876543210
7824                                                          110001x0001xxxxx111xxxxxxxxxxxxx
7825                                                          ldff1b.  */
7826                                                       return 1635;
7827                                                     }
7828                                                   else
7829                                                     {
7830                                                       /* 33222222222211111111110000000000
7831                                                          10987654321098765432109876543210
7832                                                          110001x0011xxxxx111xxxxxxxxxxxxx
7833                                                          prfd.  */
7834                                                       return 1772;
7835                                                     }
7836                                                 }
7837                                             }
7838                                           else
7839                                             {
7840                                               if (((word >> 22) & 0x1) == 0)
7841                                                 {
7842                                                   if (((word >> 31) & 0x1) == 0)
7843                                                     {
7844                                                       if (((word >> 10) & 0x1) == 0)
7845                                                         {
7846                                                           if (((word >> 12) & 0x1) == 0)
7847                                                             {
7848                                                               /* 33222222222211111111110000000000
7849                                                                  10987654321098765432109876543210
7850                                                                  010001x0101xxxxx1110x0xxxxxxxxxx
7851                                                                  sqdmullb.  */
7852                                                               return 2181;
7853                                                             }
7854                                                           else
7855                                                             {
7856                                                               if (((word >> 11) & 0x1) == 0)
7857                                                                 {
7858                                                                   /* 33222222222211111111110000000000
7859                                                                      10987654321098765432109876543210
7860                                                                      010001x0101xxxxx111100xxxxxxxxxx
7861                                                                      sqdmulh.  */
7862                                                                   return 2178;
7863                                                                 }
7864                                                               else
7865                                                                 {
7866                                                                   /* 33222222222211111111110000000000
7867                                                                      10987654321098765432109876543210
7868                                                                      010001x0101xxxxx111110xxxxxxxxxx
7869                                                                      mul.  */
7870                                                                   return 2105;
7871                                                                 }
7872                                                             }
7873                                                         }
7874                                                       else
7875                                                         {
7876                                                           if (((word >> 12) & 0x1) == 0)
7877                                                             {
7878                                                               /* 33222222222211111111110000000000
7879                                                                  10987654321098765432109876543210
7880                                                                  010001x0101xxxxx1110x1xxxxxxxxxx
7881                                                                  sqdmullt.  */
7882                                                               return 2184;
7883                                                             }
7884                                                           else
7885                                                             {
7886                                                               /* 33222222222211111111110000000000
7887                                                                  10987654321098765432109876543210
7888                                                                  010001x0101xxxxx1111x1xxxxxxxxxx
7889                                                                  sqrdmulh.  */
7890                                                               return 2200;
7891                                                             }
7892                                                         }
7893                                                     }
7894                                                   else
7895                                                     {
7896                                                       /* 33222222222211111111110000000000
7897                                                          10987654321098765432109876543210
7898                                                          110001x0101xxxxx111xxxxxxxxxxxxx
7899                                                          ldff1h.  */
7900                                                       return 1656;
7901                                                     }
7902                                                 }
7903                                               else
7904                                                 {
7905                                                   if (((word >> 31) & 0x1) == 0)
7906                                                     {
7907                                                       if (((word >> 10) & 0x1) == 0)
7908                                                         {
7909                                                           if (((word >> 12) & 0x1) == 0)
7910                                                             {
7911                                                               /* 33222222222211111111110000000000
7912                                                                  10987654321098765432109876543210
7913                                                                  010001x0111xxxxx1110x0xxxxxxxxxx
7914                                                                  sqdmullb.  */
7915                                                               return 2182;
7916                                                             }
7917                                                           else
7918                                                             {
7919                                                               if (((word >> 11) & 0x1) == 0)
7920                                                                 {
7921                                                                   /* 33222222222211111111110000000000
7922                                                                      10987654321098765432109876543210
7923                                                                      010001x0111xxxxx111100xxxxxxxxxx
7924                                                                      sqdmulh.  */
7925                                                                   return 2179;
7926                                                                 }
7927                                                               else
7928                                                                 {
7929                                                                   /* 33222222222211111111110000000000
7930                                                                      10987654321098765432109876543210
7931                                                                      010001x0111xxxxx111110xxxxxxxxxx
7932                                                                      mul.  */
7933                                                                   return 2106;
7934                                                                 }
7935                                                             }
7936                                                         }
7937                                                       else
7938                                                         {
7939                                                           if (((word >> 12) & 0x1) == 0)
7940                                                             {
7941                                                               /* 33222222222211111111110000000000
7942                                                                  10987654321098765432109876543210
7943                                                                  010001x0111xxxxx1110x1xxxxxxxxxx
7944                                                                  sqdmullt.  */
7945                                                               return 2185;
7946                                                             }
7947                                                           else
7948                                                             {
7949                                                               /* 33222222222211111111110000000000
7950                                                                  10987654321098765432109876543210
7951                                                                  010001x0111xxxxx1111x1xxxxxxxxxx
7952                                                                  sqrdmulh.  */
7953                                                               return 2201;
7954                                                             }
7955                                                         }
7956                                                     }
7957                                                   else
7958                                                     {
7959                                                       /* 33222222222211111111110000000000
7960                                                          10987654321098765432109876543210
7961                                                          110001x0111xxxxx111xxxxxxxxxxxxx
7962                                                          ldff1h.  */
7963                                                       return 1654;
7964                                                     }
7965                                                 }
7966                                             }
7967                                         }
7968                                     }
7969                                 }
7970                             }
7971                         }
7972                     }
7973                   else
7974                     {
7975                       if (((word >> 21) & 0x1) == 0)
7976                         {
7977                           if (((word >> 15) & 0x1) == 0)
7978                             {
7979                               if (((word >> 30) & 0x1) == 0)
7980                                 {
7981                                   if (((word >> 13) & 0x1) == 0)
7982                                     {
7983                                       if (((word >> 14) & 0x1) == 0)
7984                                         {
7985                                           if (((word >> 31) & 0x1) == 0)
7986                                             {
7987                                               if (((word >> 4) & 0x1) == 0)
7988                                                 {
7989                                                   /* 33222222222211111111110000000000
7990                                                      10987654321098765432109876543210
7991                                                      001001x0xx0xxxxx000xxxxxxxx0xxxx
7992                                                      cmphs.  */
7993                                                   return 1328;
7994                                                 }
7995                                               else
7996                                                 {
7997                                                   /* 33222222222211111111110000000000
7998                                                      10987654321098765432109876543210
7999                                                      001001x0xx0xxxxx000xxxxxxxx1xxxx
8000                                                      cmphi.  */
8001                                                   return 1325;
8002                                                 }
8003                                             }
8004                                           else
8005                                             {
8006                                               if (((word >> 23) & 0x1) == 0)
8007                                                 {
8008                                                   /* 33222222222211111111110000000000
8009                                                      10987654321098765432109876543210
8010                                                      101001x00x0xxxxx000xxxxxxxxxxxxx
8011                                                      ld1rqb.  */
8012                                                   return 1542;
8013                                                 }
8014                                               else
8015                                                 {
8016                                                   /* 33222222222211111111110000000000
8017                                                      10987654321098765432109876543210
8018                                                      101001x01x0xxxxx000xxxxxxxxxxxxx
8019                                                      ld1rqh.  */
8020                                                   return 1546;
8021                                                 }
8022                                             }
8023                                         }
8024                                       else
8025                                         {
8026                                           if (((word >> 31) & 0x1) == 0)
8027                                             {
8028                                               if (((word >> 4) & 0x1) == 0)
8029                                                 {
8030                                                   /* 33222222222211111111110000000000
8031                                                      10987654321098765432109876543210
8032                                                      001001x0xx0xxxxx010xxxxxxxx0xxxx
8033                                                      cmpge.  */
8034                                                   return 1319;
8035                                                 }
8036                                               else
8037                                                 {
8038                                                   /* 33222222222211111111110000000000
8039                                                      10987654321098765432109876543210
8040                                                      001001x0xx0xxxxx010xxxxxxxx1xxxx
8041                                                      cmpgt.  */
8042                                                   return 1322;
8043                                                 }
8044                                             }
8045                                           else
8046                                             {
8047                                               if (((word >> 22) & 0x1) == 0)
8048                                                 {
8049                                                   if (((word >> 23) & 0x1) == 0)
8050                                                     {
8051                                                       /* 33222222222211111111110000000000
8052                                                          10987654321098765432109876543210
8053                                                          101001x0000xxxxx010xxxxxxxxxxxxx
8054                                                          ld1b.  */
8055                                                       return 1500;
8056                                                     }
8057                                                   else
8058                                                     {
8059                                                       /* 33222222222211111111110000000000
8060                                                          10987654321098765432109876543210
8061                                                          101001x0100xxxxx010xxxxxxxxxxxxx
8062                                                          ld1sw.  */
8063                                                       return 1580;
8064                                                     }
8065                                                 }
8066                                               else
8067                                                 {
8068                                                   if (((word >> 23) & 0x1) == 0)
8069                                                     {
8070                                                       /* 33222222222211111111110000000000
8071                                                          10987654321098765432109876543210
8072                                                          101001x0010xxxxx010xxxxxxxxxxxxx
8073                                                          ld1b.  */
8074                                                       return 1502;
8075                                                     }
8076                                                   else
8077                                                     {
8078                                                       /* 33222222222211111111110000000000
8079                                                          10987654321098765432109876543210
8080                                                          101001x0110xxxxx010xxxxxxxxxxxxx
8081                                                          ld1h.  */
8082                                                       return 1522;
8083                                                     }
8084                                                 }
8085                                             }
8086                                         }
8087                                     }
8088                                   else
8089                                     {
8090                                       if (((word >> 14) & 0x1) == 0)
8091                                         {
8092                                           if (((word >> 31) & 0x1) == 0)
8093                                             {
8094                                               if (((word >> 4) & 0x1) == 0)
8095                                                 {
8096                                                   /* 33222222222211111111110000000000
8097                                                      10987654321098765432109876543210
8098                                                      001001x0xx0xxxxx001xxxxxxxx0xxxx
8099                                                      cmpeq.  */
8100                                                   return 1316;
8101                                                 }
8102                                               else
8103                                                 {
8104                                                   /* 33222222222211111111110000000000
8105                                                      10987654321098765432109876543210
8106                                                      001001x0xx0xxxxx001xxxxxxxx1xxxx
8107                                                      cmpne.  */
8108                                                   return 1339;
8109                                                 }
8110                                             }
8111                                           else
8112                                             {
8113                                               if (((word >> 23) & 0x1) == 0)
8114                                                 {
8115                                                   /* 33222222222211111111110000000000
8116                                                      10987654321098765432109876543210
8117                                                      101001x00x0xxxxx001xxxxxxxxxxxxx
8118                                                      ld1rqb.  */
8119                                                   return 1541;
8120                                                 }
8121                                               else
8122                                                 {
8123                                                   /* 33222222222211111111110000000000
8124                                                      10987654321098765432109876543210
8125                                                      101001x01x0xxxxx001xxxxxxxxxxxxx
8126                                                      ld1rqh.  */
8127                                                   return 1545;
8128                                                 }
8129                                             }
8130                                         }
8131                                       else
8132                                         {
8133                                           if (((word >> 31) & 0x1) == 0)
8134                                             {
8135                                               if (((word >> 4) & 0x1) == 0)
8136                                                 {
8137                                                   /* 33222222222211111111110000000000
8138                                                      10987654321098765432109876543210
8139                                                      001001x0xx0xxxxx011xxxxxxxx0xxxx
8140                                                      cmplt.  */
8141                                                   return 1337;
8142                                                 }
8143                                               else
8144                                                 {
8145                                                   /* 33222222222211111111110000000000
8146                                                      10987654321098765432109876543210
8147                                                      001001x0xx0xxxxx011xxxxxxxx1xxxx
8148                                                      cmple.  */
8149                                                   return 1331;
8150                                                 }
8151                                             }
8152                                           else
8153                                             {
8154                                               if (((word >> 22) & 0x1) == 0)
8155                                                 {
8156                                                   if (((word >> 23) & 0x1) == 0)
8157                                                     {
8158                                                       /* 33222222222211111111110000000000
8159                                                          10987654321098765432109876543210
8160                                                          101001x0000xxxxx011xxxxxxxxxxxxx
8161                                                          ldff1b.  */
8162                                                       return 1624;
8163                                                     }
8164                                                   else
8165                                                     {
8166                                                       /* 33222222222211111111110000000000
8167                                                          10987654321098765432109876543210
8168                                                          101001x0100xxxxx011xxxxxxxxxxxxx
8169                                                          ldff1sw.  */
8170                                                       return 1680;
8171                                                     }
8172                                                 }
8173                                               else
8174                                                 {
8175                                                   if (((word >> 23) & 0x1) == 0)
8176                                                     {
8177                                                       /* 33222222222211111111110000000000
8178                                                          10987654321098765432109876543210
8179                                                          101001x0010xxxxx011xxxxxxxxxxxxx
8180                                                          ldff1b.  */
8181                                                       return 1628;
8182                                                     }
8183                                                   else
8184                                                     {
8185                                                       /* 33222222222211111111110000000000
8186                                                          10987654321098765432109876543210
8187                                                          101001x0110xxxxx011xxxxxxxxxxxxx
8188                                                          ldff1h.  */
8189                                                       return 1647;
8190                                                     }
8191                                                 }
8192                                             }
8193                                         }
8194                                     }
8195                                 }
8196                               else
8197                                 {
8198                                   if (((word >> 31) & 0x1) == 0)
8199                                     {
8200                                       /* 33222222222211111111110000000000
8201                                          10987654321098765432109876543210
8202                                          011001x0xx0xxxxx0xxxxxxxxxxxxxxx
8203                                          fcmla.  */
8204                                       return 1385;
8205                                     }
8206                                   else
8207                                     {
8208                                       if (((word >> 13) & 0x1) == 0)
8209                                         {
8210                                           if (((word >> 22) & 0x1) == 0)
8211                                             {
8212                                               /* 33222222222211111111110000000000
8213                                                  10987654321098765432109876543210
8214                                                  111001x0x00xxxxx0x0xxxxxxxxxxxxx
8215                                                  st1b.  */
8216                                               return 1862;
8217                                             }
8218                                           else
8219                                             {
8220                                               if (((word >> 23) & 0x1) == 0)
8221                                                 {
8222                                                   /* 33222222222211111111110000000000
8223                                                      10987654321098765432109876543210
8224                                                      111001x0010xxxxx0x0xxxxxxxxxxxxx
8225                                                      st1b.  */
8226                                                   return 1866;
8227                                                 }
8228                                               else
8229                                                 {
8230                                                   /* 33222222222211111111110000000000
8231                                                      10987654321098765432109876543210
8232                                                      111001x0110xxxxx0x0xxxxxxxxxxxxx
8233                                                      st1h.  */
8234                                                   return 1887;
8235                                                 }
8236                                             }
8237                                         }
8238                                       else
8239                                         {
8240                                           if (((word >> 14) & 0x1) == 0)
8241                                             {
8242                                               if (((word >> 22) & 0x1) == 0)
8243                                                 {
8244                                                   if (((word >> 23) & 0x1) == 0)
8245                                                     {
8246                                                       /* 33222222222211111111110000000000
8247                                                          10987654321098765432109876543210
8248                                                          111001x0000xxxxx001xxxxxxxxxxxxx
8249                                                          stnt1b.  */
8250                                                       return 2239;
8251                                                     }
8252                                                   else
8253                                                     {
8254                                                       /* 33222222222211111111110000000000
8255                                                          10987654321098765432109876543210
8256                                                          111001x0100xxxxx001xxxxxxxxxxxxx
8257                                                          stnt1h.  */
8258                                                       return 2242;
8259                                                     }
8260                                                 }
8261                                               else
8262                                                 {
8263                                                   if (((word >> 23) & 0x1) == 0)
8264                                                     {
8265                                                       /* 33222222222211111111110000000000
8266                                                          10987654321098765432109876543210
8267                                                          111001x0010xxxxx001xxxxxxxxxxxxx
8268                                                          stnt1b.  */
8269                                                       return 2238;
8270                                                     }
8271                                                   else
8272                                                     {
8273                                                       /* 33222222222211111111110000000000
8274                                                          10987654321098765432109876543210
8275                                                          111001x0110xxxxx001xxxxxxxxxxxxx
8276                                                          stnt1h.  */
8277                                                       return 2241;
8278                                                     }
8279                                                 }
8280                                             }
8281                                           else
8282                                             {
8283                                               if (((word >> 22) & 0x1) == 0)
8284                                                 {
8285                                                   if (((word >> 23) & 0x1) == 0)
8286                                                     {
8287                                                       /* 33222222222211111111110000000000
8288                                                          10987654321098765432109876543210
8289                                                          111001x0000xxxxx011xxxxxxxxxxxxx
8290                                                          stnt1b.  */
8291                                                       return 1932;
8292                                                     }
8293                                                   else
8294                                                     {
8295                                                       /* 33222222222211111111110000000000
8296                                                          10987654321098765432109876543210
8297                                                          111001x0100xxxxx011xxxxxxxxxxxxx
8298                                                          stnt1h.  */
8299                                                       return 1936;
8300                                                     }
8301                                                 }
8302                                               else
8303                                                 {
8304                                                   if (((word >> 23) & 0x1) == 0)
8305                                                     {
8306                                                       /* 33222222222211111111110000000000
8307                                                          10987654321098765432109876543210
8308                                                          111001x0010xxxxx011xxxxxxxxxxxxx
8309                                                          st3b.  */
8310                                                       return 1916;
8311                                                     }
8312                                                   else
8313                                                     {
8314                                                       /* 33222222222211111111110000000000
8315                                                          10987654321098765432109876543210
8316                                                          111001x0110xxxxx011xxxxxxxxxxxxx
8317                                                          st3h.  */
8318                                                       return 1920;
8319                                                     }
8320                                                 }
8321                                             }
8322                                         }
8323                                     }
8324                                 }
8325                             }
8326                           else
8327                             {
8328                               if (((word >> 13) & 0x1) == 0)
8329                                 {
8330                                   if (((word >> 30) & 0x1) == 0)
8331                                     {
8332                                       if (((word >> 14) & 0x1) == 0)
8333                                         {
8334                                           if (((word >> 4) & 0x1) == 0)
8335                                             {
8336                                               /* 33222222222211111111110000000000
8337                                                  10987654321098765432109876543210
8338                                                  x01001x0xx0xxxxx100xxxxxxxx0xxxx
8339                                                  cmpge.  */
8340                                               return 1320;
8341                                             }
8342                                           else
8343                                             {
8344                                               /* 33222222222211111111110000000000
8345                                                  10987654321098765432109876543210
8346                                                  x01001x0xx0xxxxx100xxxxxxxx1xxxx
8347                                                  cmpgt.  */
8348                                               return 1323;
8349                                             }
8350                                         }
8351                                       else
8352                                         {
8353                                           if (((word >> 31) & 0x1) == 0)
8354                                             {
8355                                               if (((word >> 4) & 0x1) == 0)
8356                                                 {
8357                                                   /* 33222222222211111111110000000000
8358                                                      10987654321098765432109876543210
8359                                                      001001x0xx0xxxxx110xxxxxxxx0xxxx
8360                                                      cmphs.  */
8361                                                   return 1329;
8362                                                 }
8363                                               else
8364                                                 {
8365                                                   /* 33222222222211111111110000000000
8366                                                      10987654321098765432109876543210
8367                                                      001001x0xx0xxxxx110xxxxxxxx1xxxx
8368                                                      cmphi.  */
8369                                                   return 1326;
8370                                                 }
8371                                             }
8372                                           else
8373                                             {
8374                                               if (((word >> 22) & 0x1) == 0)
8375                                                 {
8376                                                   if (((word >> 23) & 0x1) == 0)
8377                                                     {
8378                                                       /* 33222222222211111111110000000000
8379                                                          10987654321098765432109876543210
8380                                                          101001x0000xxxxx110xxxxxxxxxxxxx
8381                                                          ldnt1b.  */
8382                                                       return 1715;
8383                                                     }
8384                                                   else
8385                                                     {
8386                                                       /* 33222222222211111111110000000000
8387                                                          10987654321098765432109876543210
8388                                                          101001x0100xxxxx110xxxxxxxxxxxxx
8389                                                          ldnt1h.  */
8390                                                       return 1719;
8391                                                     }
8392                                                 }
8393                                               else
8394                                                 {
8395                                                   if (((word >> 23) & 0x1) == 0)
8396                                                     {
8397                                                       /* 33222222222211111111110000000000
8398                                                          10987654321098765432109876543210
8399                                                          101001x0010xxxxx110xxxxxxxxxxxxx
8400                                                          ld3b.  */
8401                                                       return 1607;
8402                                                     }
8403                                                   else
8404                                                     {
8405                                                       /* 33222222222211111111110000000000
8406                                                          10987654321098765432109876543210
8407                                                          101001x0110xxxxx110xxxxxxxxxxxxx
8408                                                          ld3h.  */
8409                                                       return 1611;
8410                                                     }
8411                                                 }
8412                                             }
8413                                         }
8414                                     }
8415                                   else
8416                                     {
8417                                       if (((word >> 31) & 0x1) == 0)
8418                                         {
8419                                           if (((word >> 17) & 0x1) == 0)
8420                                             {
8421                                               if (((word >> 18) & 0x1) == 0)
8422                                                 {
8423                                                   if (((word >> 20) & 0x1) == 0)
8424                                                     {
8425                                                       /* 33222222222211111111110000000000
8426                                                          10987654321098765432109876543210
8427                                                          011001x0xx00x00x1x0xxxxxxxxxxxxx
8428                                                          fcadd.  */
8429                                                       return 1384;
8430                                                     }
8431                                                   else
8432                                                     {
8433                                                       /* 33222222222211111111110000000000
8434                                                          10987654321098765432109876543210
8435                                                          011001x0xx01x00x1x0xxxxxxxxxxxxx
8436                                                          faddp.  */
8437                                                       return 2065;
8438                                                     }
8439                                                 }
8440                                               else
8441                                                 {
8442                                                   if (((word >> 16) & 0x1) == 0)
8443                                                     {
8444                                                       /* 33222222222211111111110000000000
8445                                                          10987654321098765432109876543210
8446                                                          011001x0xx0xx1001x0xxxxxxxxxxxxx
8447                                                          fmaxnmp.  */
8448                                                       return 2073;
8449                                                     }
8450                                                   else
8451                                                     {
8452                                                       /* 33222222222211111111110000000000
8453                                                          10987654321098765432109876543210
8454                                                          011001x0xx0xx1011x0xxxxxxxxxxxxx
8455                                                          fminnmp.  */
8456                                                       return 2075;
8457                                                     }
8458                                                 }
8459                                             }
8460                                           else
8461                                             {
8462                                               if (((word >> 16) & 0x1) == 0)
8463                                                 {
8464                                                   /* 33222222222211111111110000000000
8465                                                      10987654321098765432109876543210
8466                                                      011001x0xx0xxx101x0xxxxxxxxxxxxx
8467                                                      fmaxp.  */
8468                                                   return 2074;
8469                                                 }
8470                                               else
8471                                                 {
8472                                                   /* 33222222222211111111110000000000
8473                                                      10987654321098765432109876543210
8474                                                      011001x0xx0xxx111x0xxxxxxxxxxxxx
8475                                                      fminp.  */
8476                                                   return 2076;
8477                                                 }
8478                                             }
8479                                         }
8480                                       else
8481                                         {
8482                                           if (((word >> 22) & 0x1) == 0)
8483                                             {
8484                                               if (((word >> 23) & 0x1) == 0)
8485                                                 {
8486                                                   /* 33222222222211111111110000000000
8487                                                      10987654321098765432109876543210
8488                                                      111001x0000xxxxx1x0xxxxxxxxxxxxx
8489                                                      st1b.  */
8490                                                   return 1863;
8491                                                 }
8492                                               else
8493                                                 {
8494                                                   /* 33222222222211111111110000000000
8495                                                      10987654321098765432109876543210
8496                                                      111001x0100xxxxx1x0xxxxxxxxxxxxx
8497                                                      st1h.  */
8498                                                   return 1882;
8499                                                 }
8500                                             }
8501                                           else
8502                                             {
8503                                               if (((word >> 23) & 0x1) == 0)
8504                                                 {
8505                                                   /* 33222222222211111111110000000000
8506                                                      10987654321098765432109876543210
8507                                                      111001x0010xxxxx1x0xxxxxxxxxxxxx
8508                                                      st1b.  */
8509                                                   return 1867;
8510                                                 }
8511                                               else
8512                                                 {
8513                                                   /* 33222222222211111111110000000000
8514                                                      10987654321098765432109876543210
8515                                                      111001x0110xxxxx1x0xxxxxxxxxxxxx
8516                                                      st1h.  */
8517                                                   return 1888;
8518                                                 }
8519                                             }
8520                                         }
8521                                     }
8522                                 }
8523                               else
8524                                 {
8525                                   if (((word >> 14) & 0x1) == 0)
8526                                     {
8527                                       if (((word >> 30) & 0x1) == 0)
8528                                         {
8529                                           if (((word >> 31) & 0x1) == 0)
8530                                             {
8531                                               if (((word >> 4) & 0x1) == 0)
8532                                                 {
8533                                                   /* 33222222222211111111110000000000
8534                                                      10987654321098765432109876543210
8535                                                      001001x0xx0xxxxx101xxxxxxxx0xxxx
8536                                                      cmpeq.  */
8537                                                   return 1317;
8538                                                 }
8539                                               else
8540                                                 {
8541                                                   /* 33222222222211111111110000000000
8542                                                      10987654321098765432109876543210
8543                                                      001001x0xx0xxxxx101xxxxxxxx1xxxx
8544                                                      cmpne.  */
8545                                                   return 1340;
8546                                                 }
8547                                             }
8548                                           else
8549                                             {
8550                                               if (((word >> 20) & 0x1) == 0)
8551                                                 {
8552                                                   if (((word >> 22) & 0x1) == 0)
8553                                                     {
8554                                                       if (((word >> 23) & 0x1) == 0)
8555                                                         {
8556                                                           /* 33222222222211111111110000000000
8557                                                              10987654321098765432109876543210
8558                                                              101001x00000xxxx101xxxxxxxxxxxxx
8559                                                              ld1b.  */
8560                                                           return 1507;
8561                                                         }
8562                                                       else
8563                                                         {
8564                                                           /* 33222222222211111111110000000000
8565                                                              10987654321098765432109876543210
8566                                                              101001x01000xxxx101xxxxxxxxxxxxx
8567                                                              ld1sw.  */
8568                                                           return 1585;
8569                                                         }
8570                                                     }
8571                                                   else
8572                                                     {
8573                                                       if (((word >> 23) & 0x1) == 0)
8574                                                         {
8575                                                           /* 33222222222211111111110000000000
8576                                                              10987654321098765432109876543210
8577                                                              101001x00100xxxx101xxxxxxxxxxxxx
8578                                                              ld1b.  */
8579                                                           return 1509;
8580                                                         }
8581                                                       else
8582                                                         {
8583                                                           /* 33222222222211111111110000000000
8584                                                              10987654321098765432109876543210
8585                                                              101001x01100xxxx101xxxxxxxxxxxxx
8586                                                              ld1h.  */
8587                                                           return 1530;
8588                                                         }
8589                                                     }
8590                                                 }
8591                                               else
8592                                                 {
8593                                                   if (((word >> 22) & 0x1) == 0)
8594                                                     {
8595                                                       if (((word >> 23) & 0x1) == 0)
8596                                                         {
8597                                                           /* 33222222222211111111110000000000
8598                                                              10987654321098765432109876543210
8599                                                              101001x00001xxxx101xxxxxxxxxxxxx
8600                                                              ldnf1b.  */
8601                                                           return 1699;
8602                                                         }
8603                                                       else
8604                                                         {
8605                                                           /* 33222222222211111111110000000000
8606                                                              10987654321098765432109876543210
8607                                                              101001x01001xxxx101xxxxxxxxxxxxx
8608                                                              ldnf1sw.  */
8609                                                           return 1712;
8610                                                         }
8611                                                     }
8612                                                   else
8613                                                     {
8614                                                       if (((word >> 23) & 0x1) == 0)
8615                                                         {
8616                                                           /* 33222222222211111111110000000000
8617                                                              10987654321098765432109876543210
8618                                                              101001x00101xxxx101xxxxxxxxxxxxx
8619                                                              ldnf1b.  */
8620                                                           return 1701;
8621                                                         }
8622                                                       else
8623                                                         {
8624                                                           /* 33222222222211111111110000000000
8625                                                              10987654321098765432109876543210
8626                                                              101001x01101xxxx101xxxxxxxxxxxxx
8627                                                              ldnf1h.  */
8628                                                           return 1705;
8629                                                         }
8630                                                     }
8631                                                 }
8632                                             }
8633                                         }
8634                                       else
8635                                         {
8636                                           if (((word >> 22) & 0x1) == 0)
8637                                             {
8638                                               if (((word >> 23) & 0x1) == 0)
8639                                                 {
8640                                                   if (((word >> 31) & 0x1) == 0)
8641                                                     {
8642                                                       /* 33222222222211111111110000000000
8643                                                          10987654321098765432109876543210
8644                                                          011001x0000xxxxx101xxxxxxxxxxxxx
8645                                                          fcvtxnt.  */
8646                                                       return 2071;
8647                                                     }
8648                                                   else
8649                                                     {
8650                                                       /* 33222222222211111111110000000000
8651                                                          10987654321098765432109876543210
8652                                                          111001x0000xxxxx101xxxxxxxxxxxxx
8653                                                          st1b.  */
8654                                                       return 1864;
8655                                                     }
8656                                                 }
8657                                               else
8658                                                 {
8659                                                   if (((word >> 31) & 0x1) == 0)
8660                                                     {
8661                                                       if (((word >> 16) & 0x1) == 0)
8662                                                         {
8663                                                           /* 33222222222211111111110000000000
8664                                                              10987654321098765432109876543210
8665                                                              011001x0100xxxx0101xxxxxxxxxxxxx
8666                                                              fcvtnt.  */
8667                                                           return 2068;
8668                                                         }
8669                                                       else
8670                                                         {
8671                                                           /* 33222222222211111111110000000000
8672                                                              10987654321098765432109876543210
8673                                                              011001x0100xxxx1101xxxxxxxxxxxxx
8674                                                              fcvtlt.  */
8675                                                           return 2066;
8676                                                         }
8677                                                     }
8678                                                   else
8679                                                     {
8680                                                       /* 33222222222211111111110000000000
8681                                                          10987654321098765432109876543210
8682                                                          111001x0100xxxxx101xxxxxxxxxxxxx
8683                                                          st1h.  */
8684                                                       return 1883;
8685                                                     }
8686                                                 }
8687                                             }
8688                                           else
8689                                             {
8690                                               if (((word >> 23) & 0x1) == 0)
8691                                                 {
8692                                                   /* 33222222222211111111110000000000
8693                                                      10987654321098765432109876543210
8694                                                      x11001x0010xxxxx101xxxxxxxxxxxxx
8695                                                      st1b.  */
8696                                                   return 1871;
8697                                                 }
8698                                               else
8699                                                 {
8700                                                   if (((word >> 31) & 0x1) == 0)
8701                                                     {
8702                                                       if (((word >> 16) & 0x1) == 0)
8703                                                         {
8704                                                           /* 33222222222211111111110000000000
8705                                                              10987654321098765432109876543210
8706                                                              011001x0110xxxx0101xxxxxxxxxxxxx
8707                                                              fcvtnt.  */
8708                                                           return 2069;
8709                                                         }
8710                                                       else
8711                                                         {
8712                                                           /* 33222222222211111111110000000000
8713                                                              10987654321098765432109876543210
8714                                                              011001x0110xxxx1101xxxxxxxxxxxxx
8715                                                              fcvtlt.  */
8716                                                           return 2067;
8717                                                         }
8718                                                     }
8719                                                   else
8720                                                     {
8721                                                       /* 33222222222211111111110000000000
8722                                                          10987654321098765432109876543210
8723                                                          111001x0110xxxxx101xxxxxxxxxxxxx
8724                                                          st1h.  */
8725                                                       return 1892;
8726                                                     }
8727                                                 }
8728                                             }
8729                                         }
8730                                     }
8731                                   else
8732                                     {
8733                                       if (((word >> 30) & 0x1) == 0)
8734                                         {
8735                                           if (((word >> 31) & 0x1) == 0)
8736                                             {
8737                                               if (((word >> 4) & 0x1) == 0)
8738                                                 {
8739                                                   /* 33222222222211111111110000000000
8740                                                      10987654321098765432109876543210
8741                                                      001001x0xx0xxxxx111xxxxxxxx0xxxx
8742                                                      cmplo.  */
8743                                                   return 1333;
8744                                                 }
8745                                               else
8746                                                 {
8747                                                   /* 33222222222211111111110000000000
8748                                                      10987654321098765432109876543210
8749                                                      001001x0xx0xxxxx111xxxxxxxx1xxxx
8750                                                      cmpls.  */
8751                                                   return 1335;
8752                                                 }
8753                                             }
8754                                           else
8755                                             {
8756                                               if (((word >> 22) & 0x1) == 0)
8757                                                 {
8758                                                   if (((word >> 23) & 0x1) == 0)
8759                                                     {
8760                                                       /* 33222222222211111111110000000000
8761                                                          10987654321098765432109876543210
8762                                                          101001x0000xxxxx111xxxxxxxxxxxxx
8763                                                          ldnt1b.  */
8764                                                       return 1716;
8765                                                     }
8766                                                   else
8767                                                     {
8768                                                       /* 33222222222211111111110000000000
8769                                                          10987654321098765432109876543210
8770                                                          101001x0100xxxxx111xxxxxxxxxxxxx
8771                                                          ldnt1h.  */
8772                                                       return 1720;
8773                                                     }
8774                                                 }
8775                                               else
8776                                                 {
8777                                                   if (((word >> 23) & 0x1) == 0)
8778                                                     {
8779                                                       /* 33222222222211111111110000000000
8780                                                          10987654321098765432109876543210
8781                                                          101001x0010xxxxx111xxxxxxxxxxxxx
8782                                                          ld3b.  */
8783                                                       return 1608;
8784                                                     }
8785                                                   else
8786                                                     {
8787                                                       /* 33222222222211111111110000000000
8788                                                          10987654321098765432109876543210
8789                                                          101001x0110xxxxx111xxxxxxxxxxxxx
8790                                                          ld3h.  */
8791                                                       return 1612;
8792                                                     }
8793                                                 }
8794                                             }
8795                                         }
8796                                       else
8797                                         {
8798                                           if (((word >> 20) & 0x1) == 0)
8799                                             {
8800                                               if (((word >> 22) & 0x1) == 0)
8801                                                 {
8802                                                   /* 33222222222211111111110000000000
8803                                                      10987654321098765432109876543210
8804                                                      x11001x0x000xxxx111xxxxxxxxxxxxx
8805                                                      st1b.  */
8806                                                   return 1869;
8807                                                 }
8808                                               else
8809                                                 {
8810                                                   if (((word >> 23) & 0x1) == 0)
8811                                                     {
8812                                                       /* 33222222222211111111110000000000
8813                                                          10987654321098765432109876543210
8814                                                          x11001x00100xxxx111xxxxxxxxxxxxx
8815                                                          st1b.  */
8816                                                       return 1872;
8817                                                     }
8818                                                   else
8819                                                     {
8820                                                       /* 33222222222211111111110000000000
8821                                                          10987654321098765432109876543210
8822                                                          x11001x01100xxxx111xxxxxxxxxxxxx
8823                                                          st1h.  */
8824                                                       return 1893;
8825                                                     }
8826                                                 }
8827                                             }
8828                                           else
8829                                             {
8830                                               if (((word >> 22) & 0x1) == 0)
8831                                                 {
8832                                                   if (((word >> 23) & 0x1) == 0)
8833                                                     {
8834                                                       /* 33222222222211111111110000000000
8835                                                          10987654321098765432109876543210
8836                                                          x11001x00001xxxx111xxxxxxxxxxxxx
8837                                                          stnt1b.  */
8838                                                       return 1933;
8839                                                     }
8840                                                   else
8841                                                     {
8842                                                       /* 33222222222211111111110000000000
8843                                                          10987654321098765432109876543210
8844                                                          x11001x01001xxxx111xxxxxxxxxxxxx
8845                                                          stnt1h.  */
8846                                                       return 1937;
8847                                                     }
8848                                                 }
8849                                               else
8850                                                 {
8851                                                   if (((word >> 23) & 0x1) == 0)
8852                                                     {
8853                                                       /* 33222222222211111111110000000000
8854                                                          10987654321098765432109876543210
8855                                                          x11001x00101xxxx111xxxxxxxxxxxxx
8856                                                          st3b.  */
8857                                                       return 1917;
8858                                                     }
8859                                                   else
8860                                                     {
8861                                                       /* 33222222222211111111110000000000
8862                                                          10987654321098765432109876543210
8863                                                          x11001x01101xxxx111xxxxxxxxxxxxx
8864                                                          st3h.  */
8865                                                       return 1921;
8866                                                     }
8867                                                 }
8868                                             }
8869                                         }
8870                                     }
8871                                 }
8872                             }
8873                         }
8874                       else
8875                         {
8876                           if (((word >> 13) & 0x1) == 0)
8877                             {
8878                               if (((word >> 30) & 0x1) == 0)
8879                                 {
8880                                   if (((word >> 31) & 0x1) == 0)
8881                                     {
8882                                       if (((word >> 4) & 0x1) == 0)
8883                                         {
8884                                           /* 33222222222211111111110000000000
8885                                              10987654321098765432109876543210
8886                                              001001x0xx1xxxxxxx0xxxxxxxx0xxxx
8887                                              cmphs.  */
8888                                           return 1330;
8889                                         }
8890                                       else
8891                                         {
8892                                           /* 33222222222211111111110000000000
8893                                              10987654321098765432109876543210
8894                                              001001x0xx1xxxxxxx0xxxxxxxx1xxxx
8895                                              cmphi.  */
8896                                           return 1327;
8897                                         }
8898                                     }
8899                                   else
8900                                     {
8901                                       if (((word >> 15) & 0x1) == 0)
8902                                         {
8903                                           if (((word >> 22) & 0x1) == 0)
8904                                             {
8905                                               if (((word >> 23) & 0x1) == 0)
8906                                                 {
8907                                                   /* 33222222222211111111110000000000
8908                                                      10987654321098765432109876543210
8909                                                      101001x0001xxxxx0x0xxxxxxxxxxxxx
8910                                                      ld1b.  */
8911                                                   return 1501;
8912                                                 }
8913                                               else
8914                                                 {
8915                                                   /* 33222222222211111111110000000000
8916                                                      10987654321098765432109876543210
8917                                                      101001x0101xxxxx0x0xxxxxxxxxxxxx
8918                                                      ld1h.  */
8919                                                   return 1521;
8920                                                 }
8921                                             }
8922                                           else
8923                                             {
8924                                               if (((word >> 23) & 0x1) == 0)
8925                                                 {
8926                                                   /* 33222222222211111111110000000000
8927                                                      10987654321098765432109876543210
8928                                                      101001x0011xxxxx0x0xxxxxxxxxxxxx
8929                                                      ld1b.  */
8930                                                   return 1503;
8931                                                 }
8932                                               else
8933                                                 {
8934                                                   /* 33222222222211111111110000000000
8935                                                      10987654321098765432109876543210
8936                                                      101001x0111xxxxx0x0xxxxxxxxxxxxx
8937                                                      ld1h.  */
8938                                                   return 1523;
8939                                                 }
8940                                             }
8941                                         }
8942                                       else
8943                                         {
8944                                           if (((word >> 22) & 0x1) == 0)
8945                                             {
8946                                               if (((word >> 23) & 0x1) == 0)
8947                                                 {
8948                                                   /* 33222222222211111111110000000000
8949                                                      10987654321098765432109876543210
8950                                                      101001x0001xxxxx1x0xxxxxxxxxxxxx
8951                                                      ld2b.  */
8952                                                   return 1599;
8953                                                 }
8954                                               else
8955                                                 {
8956                                                   /* 33222222222211111111110000000000
8957                                                      10987654321098765432109876543210
8958                                                      101001x0101xxxxx1x0xxxxxxxxxxxxx
8959                                                      ld2h.  */
8960                                                   return 1603;
8961                                                 }
8962                                             }
8963                                           else
8964                                             {
8965                                               if (((word >> 23) & 0x1) == 0)
8966                                                 {
8967                                                   /* 33222222222211111111110000000000
8968                                                      10987654321098765432109876543210
8969                                                      101001x0011xxxxx1x0xxxxxxxxxxxxx
8970                                                      ld4b.  */
8971                                                   return 1615;
8972                                                 }
8973                                               else
8974                                                 {
8975                                                   /* 33222222222211111111110000000000
8976                                                      10987654321098765432109876543210
8977                                                      101001x0111xxxxx1x0xxxxxxxxxxxxx
8978                                                      ld4h.  */
8979                                                   return 1619;
8980                                                 }
8981                                             }
8982                                         }
8983                                     }
8984                                 }
8985                               else
8986                                 {
8987                                   if (((word >> 15) & 0x1) == 0)
8988                                     {
8989                                       if (((word >> 14) & 0x1) == 0)
8990                                         {
8991                                           if (((word >> 12) & 0x1) == 0)
8992                                             {
8993                                               if (((word >> 10) & 0x1) == 0)
8994                                                 {
8995                                                   if (((word >> 23) & 0x1) == 0)
8996                                                     {
8997                                                       /* 33222222222211111111110000000000
8998                                                          10987654321098765432109876543210
8999                                                          x11001x00x1xxxxx0000x0xxxxxxxxxx
9000                                                          fmla.  */
9001                                                       return 1438;
9002                                                     }
9003                                                   else
9004                                                     {
9005                                                       if (((word >> 22) & 0x1) == 0)
9006                                                         {
9007                                                           /* 33222222222211111111110000000000
9008                                                              10987654321098765432109876543210
9009                                                              x11001x0101xxxxx0000x0xxxxxxxxxx
9010                                                              fmla.  */
9011                                                           return 1439;
9012                                                         }
9013                                                       else
9014                                                         {
9015                                                           /* 33222222222211111111110000000000
9016                                                              10987654321098765432109876543210
9017                                                              x11001x0111xxxxx0000x0xxxxxxxxxx
9018                                                              fmla.  */
9019                                                           return 1440;
9020                                                         }
9021                                                     }
9022                                                 }
9023                                               else
9024                                                 {
9025                                                   if (((word >> 23) & 0x1) == 0)
9026                                                     {
9027                                                       /* 33222222222211111111110000000000
9028                                                          10987654321098765432109876543210
9029                                                          x11001x00x1xxxxx0000x1xxxxxxxxxx
9030                                                          fmls.  */
9031                                                       return 1442;
9032                                                     }
9033                                                   else
9034                                                     {
9035                                                       if (((word >> 22) & 0x1) == 0)
9036                                                         {
9037                                                           /* 33222222222211111111110000000000
9038                                                              10987654321098765432109876543210
9039                                                              x11001x0101xxxxx0000x1xxxxxxxxxx
9040                                                              fmls.  */
9041                                                           return 1443;
9042                                                         }
9043                                                       else
9044                                                         {
9045                                                           /* 33222222222211111111110000000000
9046                                                              10987654321098765432109876543210
9047                                                              x11001x0111xxxxx0000x1xxxxxxxxxx
9048                                                              fmls.  */
9049                                                           return 1444;
9050                                                         }
9051                                                     }
9052                                                 }
9053                                             }
9054                                           else
9055                                             {
9056                                               if (((word >> 22) & 0x1) == 0)
9057                                                 {
9058                                                   /* 33222222222211111111110000000000
9059                                                      10987654321098765432109876543210
9060                                                      x11001x0x01xxxxx0001xxxxxxxxxxxx
9061                                                      fcmla.  */
9062                                                   return 1386;
9063                                                 }
9064                                               else
9065                                                 {
9066                                                   /* 33222222222211111111110000000000
9067                                                      10987654321098765432109876543210
9068                                                      x11001x0x11xxxxx0001xxxxxxxxxxxx
9069                                                      fcmla.  */
9070                                                   return 1387;
9071                                                 }
9072                                             }
9073                                         }
9074                                       else
9075                                         {
9076                                           if (((word >> 22) & 0x1) == 0)
9077                                             {
9078                                               if (((word >> 23) & 0x1) == 0)
9079                                                 {
9080                                                   /* 33222222222211111111110000000000
9081                                                      10987654321098765432109876543210
9082                                                      x11001x0001xxxxx010xxxxxxxxxxxxx
9083                                                      st1b.  */
9084                                                   return 1865;
9085                                                 }
9086                                               else
9087                                                 {
9088                                                   if (((word >> 31) & 0x1) == 0)
9089                                                     {
9090                                                       if (((word >> 10) & 0x1) == 0)
9091                                                         {
9092                                                           /* 33222222222211111111110000000000
9093                                                              10987654321098765432109876543210
9094                                                              011001x0101xxxxx010xx0xxxxxxxxxx
9095                                                              fmlalb.  */
9096                                                           return 2077;
9097                                                         }
9098                                                       else
9099                                                         {
9100                                                           /* 33222222222211111111110000000000
9101                                                              10987654321098765432109876543210
9102                                                              011001x0101xxxxx010xx1xxxxxxxxxx
9103                                                              fmlalt.  */
9104                                                           return 2079;
9105                                                         }
9106                                                     }
9107                                                   else
9108                                                     {
9109                                                       /* 33222222222211111111110000000000
9110                                                          10987654321098765432109876543210
9111                                                          111001x0101xxxxx010xxxxxxxxxxxxx
9112                                                          st1h.  */
9113                                                       return 1884;
9114                                                     }
9115                                                 }
9116                                             }
9117                                           else
9118                                             {
9119                                               if (((word >> 23) & 0x1) == 0)
9120                                                 {
9121                                                   /* 33222222222211111111110000000000
9122                                                      10987654321098765432109876543210
9123                                                      x11001x0011xxxxx010xxxxxxxxxxxxx
9124                                                      st1b.  */
9125                                                   return 1868;
9126                                                 }
9127                                               else
9128                                                 {
9129                                                   /* 33222222222211111111110000000000
9130                                                      10987654321098765432109876543210
9131                                                      x11001x0111xxxxx010xxxxxxxxxxxxx
9132                                                      st1h.  */
9133                                                   return 1889;
9134                                                 }
9135                                             }
9136                                         }
9137                                     }
9138                                   else
9139                                     {
9140                                       if (((word >> 22) & 0x1) == 0)
9141                                         {
9142                                           if (((word >> 31) & 0x1) == 0)
9143                                             {
9144                                               if (((word >> 10) & 0x1) == 0)
9145                                                 {
9146                                                   /* 33222222222211111111110000000000
9147                                                      10987654321098765432109876543210
9148                                                      011001x0x01xxxxx1x0xx0xxxxxxxxxx
9149                                                      fmlalb.  */
9150                                                   return 2078;
9151                                                 }
9152                                               else
9153                                                 {
9154                                                   /* 33222222222211111111110000000000
9155                                                      10987654321098765432109876543210
9156                                                      011001x0x01xxxxx1x0xx1xxxxxxxxxx
9157                                                      fmlalt.  */
9158                                                   return 2080;
9159                                                 }
9160                                             }
9161                                           else
9162                                             {
9163                                               /* 33222222222211111111110000000000
9164                                                  10987654321098765432109876543210
9165                                                  111001x0x01xxxxx1x0xxxxxxxxxxxxx
9166                                                  st1h.  */
9167                                               return 1885;
9168                                             }
9169                                         }
9170                                       else
9171                                         {
9172                                           /* 33222222222211111111110000000000
9173                                              10987654321098765432109876543210
9174                                              x11001x0x11xxxxx1x0xxxxxxxxxxxxx
9175                                              st1h.  */
9176                                           return 1890;
9177                                         }
9178                                     }
9179                                 }
9180                             }
9181                           else
9182                             {
9183                               if (((word >> 30) & 0x1) == 0)
9184                                 {
9185                                   if (((word >> 31) & 0x1) == 0)
9186                                     {
9187                                       if (((word >> 4) & 0x1) == 0)
9188                                         {
9189                                           /* 33222222222211111111110000000000
9190                                              10987654321098765432109876543210
9191                                              001001x0xx1xxxxxxx1xxxxxxxx0xxxx
9192                                              cmplo.  */
9193                                           return 1334;
9194                                         }
9195                                       else
9196                                         {
9197                                           /* 33222222222211111111110000000000
9198                                              10987654321098765432109876543210
9199                                              001001x0xx1xxxxxxx1xxxxxxxx1xxxx
9200                                              cmpls.  */
9201                                           return 1336;
9202                                         }
9203                                     }
9204                                   else
9205                                     {
9206                                       if (((word >> 14) & 0x1) == 0)
9207                                         {
9208                                           if (((word >> 20) & 0x1) == 0)
9209                                             {
9210                                               if (((word >> 22) & 0x1) == 0)
9211                                                 {
9212                                                   if (((word >> 23) & 0x1) == 0)
9213                                                     {
9214                                                       /* 33222222222211111111110000000000
9215                                                          10987654321098765432109876543210
9216                                                          101001x00010xxxxx01xxxxxxxxxxxxx
9217                                                          ld1b.  */
9218                                                       return 1508;
9219                                                     }
9220                                                   else
9221                                                     {
9222                                                       /* 33222222222211111111110000000000
9223                                                          10987654321098765432109876543210
9224                                                          101001x01010xxxxx01xxxxxxxxxxxxx
9225                                                          ld1h.  */
9226                                                       return 1529;
9227                                                     }
9228                                                 }
9229                                               else
9230                                                 {
9231                                                   if (((word >> 23) & 0x1) == 0)
9232                                                     {
9233                                                       /* 33222222222211111111110000000000
9234                                                          10987654321098765432109876543210
9235                                                          101001x00110xxxxx01xxxxxxxxxxxxx
9236                                                          ld1b.  */
9237                                                       return 1510;
9238                                                     }
9239                                                   else
9240                                                     {
9241                                                       /* 33222222222211111111110000000000
9242                                                          10987654321098765432109876543210
9243                                                          101001x01110xxxxx01xxxxxxxxxxxxx
9244                                                          ld1h.  */
9245                                                       return 1531;
9246                                                     }
9247                                                 }
9248                                             }
9249                                           else
9250                                             {
9251                                               if (((word >> 22) & 0x1) == 0)
9252                                                 {
9253                                                   if (((word >> 23) & 0x1) == 0)
9254                                                     {
9255                                                       /* 33222222222211111111110000000000
9256                                                          10987654321098765432109876543210
9257                                                          101001x00011xxxxx01xxxxxxxxxxxxx
9258                                                          ldnf1b.  */
9259                                                       return 1700;
9260                                                     }
9261                                                   else
9262                                                     {
9263                                                       /* 33222222222211111111110000000000
9264                                                          10987654321098765432109876543210
9265                                                          101001x01011xxxxx01xxxxxxxxxxxxx
9266                                                          ldnf1h.  */
9267                                                       return 1704;
9268                                                     }
9269                                                 }
9270                                               else
9271                                                 {
9272                                                   if (((word >> 23) & 0x1) == 0)
9273                                                     {
9274                                                       /* 33222222222211111111110000000000
9275                                                          10987654321098765432109876543210
9276                                                          101001x00111xxxxx01xxxxxxxxxxxxx
9277                                                          ldnf1b.  */
9278                                                       return 1702;
9279                                                     }
9280                                                   else
9281                                                     {
9282                                                       /* 33222222222211111111110000000000
9283                                                          10987654321098765432109876543210
9284                                                          101001x01111xxxxx01xxxxxxxxxxxxx
9285                                                          ldnf1h.  */
9286                                                       return 1706;
9287                                                     }
9288                                                 }
9289                                             }
9290                                         }
9291                                       else
9292                                         {
9293                                           if (((word >> 15) & 0x1) == 0)
9294                                             {
9295                                               if (((word >> 22) & 0x1) == 0)
9296                                                 {
9297                                                   if (((word >> 23) & 0x1) == 0)
9298                                                     {
9299                                                       /* 33222222222211111111110000000000
9300                                                          10987654321098765432109876543210
9301                                                          101001x0001xxxxx011xxxxxxxxxxxxx
9302                                                          ldff1b.  */
9303                                                       return 1626;
9304                                                     }
9305                                                   else
9306                                                     {
9307                                                       /* 33222222222211111111110000000000
9308                                                          10987654321098765432109876543210
9309                                                          101001x0101xxxxx011xxxxxxxxxxxxx
9310                                                          ldff1h.  */
9311                                                       return 1645;
9312                                                     }
9313                                                 }
9314                                               else
9315                                                 {
9316                                                   if (((word >> 23) & 0x1) == 0)
9317                                                     {
9318                                                       /* 33222222222211111111110000000000
9319                                                          10987654321098765432109876543210
9320                                                          101001x0011xxxxx011xxxxxxxxxxxxx
9321                                                          ldff1b.  */
9322                                                       return 1630;
9323                                                     }
9324                                                   else
9325                                                     {
9326                                                       /* 33222222222211111111110000000000
9327                                                          10987654321098765432109876543210
9328                                                          101001x0111xxxxx011xxxxxxxxxxxxx
9329                                                          ldff1h.  */
9330                                                       return 1649;
9331                                                     }
9332                                                 }
9333                                             }
9334                                           else
9335                                             {
9336                                               if (((word >> 22) & 0x1) == 0)
9337                                                 {
9338                                                   if (((word >> 23) & 0x1) == 0)
9339                                                     {
9340                                                       /* 33222222222211111111110000000000
9341                                                          10987654321098765432109876543210
9342                                                          101001x0001xxxxx111xxxxxxxxxxxxx
9343                                                          ld2b.  */
9344                                                       return 1600;
9345                                                     }
9346                                                   else
9347                                                     {
9348                                                       /* 33222222222211111111110000000000
9349                                                          10987654321098765432109876543210
9350                                                          101001x0101xxxxx111xxxxxxxxxxxxx
9351                                                          ld2h.  */
9352                                                       return 1604;
9353                                                     }
9354                                                 }
9355                                               else
9356                                                 {
9357                                                   if (((word >> 23) & 0x1) == 0)
9358                                                     {
9359                                                       /* 33222222222211111111110000000000
9360                                                          10987654321098765432109876543210
9361                                                          101001x0011xxxxx111xxxxxxxxxxxxx
9362                                                          ld4b.  */
9363                                                       return 1616;
9364                                                     }
9365                                                   else
9366                                                     {
9367                                                       /* 33222222222211111111110000000000
9368                                                          10987654321098765432109876543210
9369                                                          101001x0111xxxxx111xxxxxxxxxxxxx
9370                                                          ld4h.  */
9371                                                       return 1620;
9372                                                     }
9373                                                 }
9374                                             }
9375                                         }
9376                                     }
9377                                 }
9378                               else
9379                                 {
9380                                   if (((word >> 14) & 0x1) == 0)
9381                                     {
9382                                       if (((word >> 15) & 0x1) == 0)
9383                                         {
9384                                           if (((word >> 23) & 0x1) == 0)
9385                                             {
9386                                               /* 33222222222211111111110000000000
9387                                                  10987654321098765432109876543210
9388                                                  x11001x00x1xxxxx001xxxxxxxxxxxxx
9389                                                  fmul.  */
9390                                               return 1449;
9391                                             }
9392                                           else
9393                                             {
9394                                               if (((word >> 22) & 0x1) == 0)
9395                                                 {
9396                                                   /* 33222222222211111111110000000000
9397                                                      10987654321098765432109876543210
9398                                                      x11001x0101xxxxx001xxxxxxxxxxxxx
9399                                                      fmul.  */
9400                                                   return 1450;
9401                                                 }
9402                                               else
9403                                                 {
9404                                                   /* 33222222222211111111110000000000
9405                                                      10987654321098765432109876543210
9406                                                      x11001x0111xxxxx001xxxxxxxxxxxxx
9407                                                      fmul.  */
9408                                                   return 1451;
9409                                                 }
9410                                             }
9411                                         }
9412                                       else
9413                                         {
9414                                           if (((word >> 22) & 0x1) == 0)
9415                                             {
9416                                               if (((word >> 31) & 0x1) == 0)
9417                                                 {
9418                                                   if (((word >> 10) & 0x1) == 0)
9419                                                     {
9420                                                       /* 33222222222211111111110000000000
9421                                                          10987654321098765432109876543210
9422                                                          011001x0x01xxxxx101xx0xxxxxxxxxx
9423                                                          fmlslb.  */
9424                                                       return 2082;
9425                                                     }
9426                                                   else
9427                                                     {
9428                                                       /* 33222222222211111111110000000000
9429                                                          10987654321098765432109876543210
9430                                                          011001x0x01xxxxx101xx1xxxxxxxxxx
9431                                                          fmlslt.  */
9432                                                       return 2084;
9433                                                     }
9434                                                 }
9435                                               else
9436                                                 {
9437                                                   /* 33222222222211111111110000000000
9438                                                      10987654321098765432109876543210
9439                                                      111001x0x01xxxxx101xxxxxxxxxxxxx
9440                                                      st1h.  */
9441                                                   return 1886;
9442                                                 }
9443                                             }
9444                                           else
9445                                             {
9446                                               if (((word >> 23) & 0x1) == 0)
9447                                                 {
9448                                                   /* 33222222222211111111110000000000
9449                                                      10987654321098765432109876543210
9450                                                      x11001x0011xxxxx101xxxxxxxxxxxxx
9451                                                      st1b.  */
9452                                                   return 1873;
9453                                                 }
9454                                               else
9455                                                 {
9456                                                   /* 33222222222211111111110000000000
9457                                                      10987654321098765432109876543210
9458                                                      x11001x0111xxxxx101xxxxxxxxxxxxx
9459                                                      st1h.  */
9460                                                   return 1894;
9461                                                 }
9462                                             }
9463                                         }
9464                                     }
9465                                   else
9466                                     {
9467                                       if (((word >> 15) & 0x1) == 0)
9468                                         {
9469                                           if (((word >> 22) & 0x1) == 0)
9470                                             {
9471                                               if (((word >> 23) & 0x1) == 0)
9472                                                 {
9473                                                   /* 33222222222211111111110000000000
9474                                                      10987654321098765432109876543210
9475                                                      x11001x0001xxxxx011xxxxxxxxxxxxx
9476                                                      st2b.  */
9477                                                   return 1908;
9478                                                 }
9479                                               else
9480                                                 {
9481                                                   if (((word >> 31) & 0x1) == 0)
9482                                                     {
9483                                                       if (((word >> 10) & 0x1) == 0)
9484                                                         {
9485                                                           /* 33222222222211111111110000000000
9486                                                              10987654321098765432109876543210
9487                                                              011001x0101xxxxx011xx0xxxxxxxxxx
9488                                                              fmlslb.  */
9489                                                           return 2081;
9490                                                         }
9491                                                       else
9492                                                         {
9493                                                           /* 33222222222211111111110000000000
9494                                                              10987654321098765432109876543210
9495                                                              011001x0101xxxxx011xx1xxxxxxxxxx
9496                                                              fmlslt.  */
9497                                                           return 2083;
9498                                                         }
9499                                                     }
9500                                                   else
9501                                                     {
9502                                                       /* 33222222222211111111110000000000
9503                                                          10987654321098765432109876543210
9504                                                          111001x0101xxxxx011xxxxxxxxxxxxx
9505                                                          st2h.  */
9506                                                       return 1912;
9507                                                     }
9508                                                 }
9509                                             }
9510                                           else
9511                                             {
9512                                               if (((word >> 23) & 0x1) == 0)
9513                                                 {
9514                                                   /* 33222222222211111111110000000000
9515                                                      10987654321098765432109876543210
9516                                                      x11001x0011xxxxx011xxxxxxxxxxxxx
9517                                                      st4b.  */
9518                                                   return 1924;
9519                                                 }
9520                                               else
9521                                                 {
9522                                                   /* 33222222222211111111110000000000
9523                                                      10987654321098765432109876543210
9524                                                      x11001x0111xxxxx011xxxxxxxxxxxxx
9525                                                      st4h.  */
9526                                                   return 1928;
9527                                                 }
9528                                             }
9529                                         }
9530                                       else
9531                                         {
9532                                           if (((word >> 20) & 0x1) == 0)
9533                                             {
9534                                               if (((word >> 22) & 0x1) == 0)
9535                                                 {
9536                                                   if (((word >> 23) & 0x1) == 0)
9537                                                     {
9538                                                       /* 33222222222211111111110000000000
9539                                                          10987654321098765432109876543210
9540                                                          x11001x00010xxxx111xxxxxxxxxxxxx
9541                                                          st1b.  */
9542                                                       return 1870;
9543                                                     }
9544                                                   else
9545                                                     {
9546                                                       /* 33222222222211111111110000000000
9547                                                          10987654321098765432109876543210
9548                                                          x11001x01010xxxx111xxxxxxxxxxxxx
9549                                                          st1h.  */
9550                                                       return 1891;
9551                                                     }
9552                                                 }
9553                                               else
9554                                                 {
9555                                                   if (((word >> 23) & 0x1) == 0)
9556                                                     {
9557                                                       /* 33222222222211111111110000000000
9558                                                          10987654321098765432109876543210
9559                                                          x11001x00110xxxx111xxxxxxxxxxxxx
9560                                                          st1b.  */
9561                                                       return 1874;
9562                                                     }
9563                                                   else
9564                                                     {
9565                                                       /* 33222222222211111111110000000000
9566                                                          10987654321098765432109876543210
9567                                                          x11001x01110xxxx111xxxxxxxxxxxxx
9568                                                          st1h.  */
9569                                                       return 1895;
9570                                                     }
9571                                                 }
9572                                             }
9573                                           else
9574                                             {
9575                                               if (((word >> 22) & 0x1) == 0)
9576                                                 {
9577                                                   if (((word >> 23) & 0x1) == 0)
9578                                                     {
9579                                                       /* 33222222222211111111110000000000
9580                                                          10987654321098765432109876543210
9581                                                          x11001x00011xxxx111xxxxxxxxxxxxx
9582                                                          st2b.  */
9583                                                       return 1909;
9584                                                     }
9585                                                   else
9586                                                     {
9587                                                       /* 33222222222211111111110000000000
9588                                                          10987654321098765432109876543210
9589                                                          x11001x01011xxxx111xxxxxxxxxxxxx
9590                                                          st2h.  */
9591                                                       return 1913;
9592                                                     }
9593                                                 }
9594                                               else
9595                                                 {
9596                                                   if (((word >> 23) & 0x1) == 0)
9597                                                     {
9598                                                       /* 33222222222211111111110000000000
9599                                                          10987654321098765432109876543210
9600                                                          x11001x00111xxxx111xxxxxxxxxxxxx
9601                                                          st4b.  */
9602                                                       return 1925;
9603                                                     }
9604                                                   else
9605                                                     {
9606                                                       /* 33222222222211111111110000000000
9607                                                          10987654321098765432109876543210
9608                                                          x11001x01111xxxx111xxxxxxxxxxxxx
9609                                                          st4h.  */
9610                                                       return 1929;
9611                                                     }
9612                                                 }
9613                                             }
9614                                         }
9615                                     }
9616                                 }
9617                             }
9618                         }
9619                     }
9620                 }
9621               else
9622                 {
9623                   if (((word >> 29) & 0x1) == 0)
9624                     {
9625                       if (((word >> 30) & 0x1) == 0)
9626                         {
9627                           if (((word >> 31) & 0x1) == 0)
9628                             {
9629                               if (((word >> 21) & 0x1) == 0)
9630                                 {
9631                                   if (((word >> 20) & 0x1) == 0)
9632                                     {
9633                                       if (((word >> 22) & 0x1) == 0)
9634                                         {
9635                                           if (((word >> 23) & 0x1) == 0)
9636                                             {
9637                                               /* 33222222222211111111110000000000
9638                                                  10987654321098765432109876543210
9639                                                  000001x10000xxxxxxxxxxxxxxxxxxxx
9640                                                  orr.  */
9641                                               return 1754;
9642                                             }
9643                                           else
9644                                             {
9645                                               /* 33222222222211111111110000000000
9646                                                  10987654321098765432109876543210
9647                                                  000001x11000xxxxxxxxxxxxxxxxxxxx
9648                                                  and.  */
9649                                               return 1282;
9650                                             }
9651                                         }
9652                                       else
9653                                         {
9654                                           if (((word >> 23) & 0x1) == 0)
9655                                             {
9656                                               /* 33222222222211111111110000000000
9657                                                  10987654321098765432109876543210
9658                                                  000001x10100xxxxxxxxxxxxxxxxxxxx
9659                                                  eor.  */
9660                                               return 1369;
9661                                             }
9662                                           else
9663                                             {
9664                                               /* 33222222222211111111110000000000
9665                                                  10987654321098765432109876543210
9666                                                  000001x11100xxxxxxxxxxxxxxxxxxxx
9667                                                  dupm.  */
9668                                               return 1367;
9669                                             }
9670                                         }
9671                                     }
9672                                   else
9673                                     {
9674                                       if (((word >> 15) & 0x1) == 0)
9675                                         {
9676                                           /* 33222222222211111111110000000000
9677                                              10987654321098765432109876543210
9678                                              000001x1xx01xxxx0xxxxxxxxxxxxxxx
9679                                              cpy.  */
9680                                           return 1352;
9681                                         }
9682                                       else
9683                                         {
9684                                           /* 33222222222211111111110000000000
9685                                              10987654321098765432109876543210
9686                                              000001x1xx01xxxx1xxxxxxxxxxxxxxx
9687                                              fcpy.  */
9688                                           return 1399;
9689                                         }
9690                                     }
9691                                 }
9692                               else
9693                                 {
9694                                   if (((word >> 14) & 0x1) == 0)
9695                                     {
9696                                       if (((word >> 13) & 0x1) == 0)
9697                                         {
9698                                           if (((word >> 15) & 0x1) == 0)
9699                                             {
9700                                               if (((word >> 22) & 0x1) == 0)
9701                                                 {
9702                                                   /* 33222222222211111111110000000000
9703                                                      10987654321098765432109876543210
9704                                                      000001x1x01xxxxx000xxxxxxxxxxxxx
9705                                                      ext.  */
9706                                                   return 1374;
9707                                                 }
9708                                               else
9709                                                 {
9710                                                   /* 33222222222211111111110000000000
9711                                                      10987654321098765432109876543210
9712                                                      000001x1x11xxxxx000xxxxxxxxxxxxx
9713                                                      ext.  */
9714                                                   return 2064;
9715                                                 }
9716                                             }
9717                                           else
9718                                             {
9719                                               if (((word >> 16) & 0x1) == 0)
9720                                                 {
9721                                                   if (((word >> 17) & 0x1) == 0)
9722                                                     {
9723                                                       if (((word >> 18) & 0x1) == 0)
9724                                                         {
9725                                                           if (((word >> 19) & 0x1) == 0)
9726                                                             {
9727                                                               /* 33222222222211111111110000000000
9728                                                                  10987654321098765432109876543210
9729                                                                  000001x1xx1x0000100xxxxxxxxxxxxx
9730                                                                  cpy.  */
9731                                                               return 1350;
9732                                                             }
9733                                                           else
9734                                                             {
9735                                                               /* 33222222222211111111110000000000
9736                                                                  10987654321098765432109876543210
9737                                                                  000001x1xx1x1000100xxxxxxxxxxxxx
9738                                                                  clasta.  */
9739                                                               return 1308;
9740                                                             }
9741                                                         }
9742                                                       else
9743                                                         {
9744                                                           if (((word >> 19) & 0x1) == 0)
9745                                                             {
9746                                                               /* 33222222222211111111110000000000
9747                                                                  10987654321098765432109876543210
9748                                                                  000001x1xx1x0100100xxxxxxxxxxxxx
9749                                                                  revb.  */
9750                                                               return 1802;
9751                                                             }
9752                                                           else
9753                                                             {
9754                                                               /* 33222222222211111111110000000000
9755                                                                  10987654321098765432109876543210
9756                                                                  000001x1xx1x1100100xxxxxxxxxxxxx
9757                                                                  splice.  */
9758                                                               return 1829;
9759                                                             }
9760                                                         }
9761                                                     }
9762                                                   else
9763                                                     {
9764                                                       if (((word >> 18) & 0x1) == 0)
9765                                                         {
9766                                                           if (((word >> 19) & 0x1) == 0)
9767                                                             {
9768                                                               /* 33222222222211111111110000000000
9769                                                                  10987654321098765432109876543210
9770                                                                  000001x1xx1x0010100xxxxxxxxxxxxx
9771                                                                  lasta.  */
9772                                                               return 1496;
9773                                                             }
9774                                                           else
9775                                                             {
9776                                                               /* 33222222222211111111110000000000
9777                                                                  10987654321098765432109876543210
9778                                                                  000001x1xx1x1010100xxxxxxxxxxxxx
9779                                                                  clasta.  */
9780                                                               return 1309;
9781                                                             }
9782                                                         }
9783                                                       else
9784                                                         {
9785                                                           /* 33222222222211111111110000000000
9786                                                              10987654321098765432109876543210
9787                                                              000001x1xx1xx110100xxxxxxxxxxxxx
9788                                                              revw.  */
9789                                                           return 1804;
9790                                                         }
9791                                                     }
9792                                                 }
9793                                               else
9794                                                 {
9795                                                   if (((word >> 17) & 0x1) == 0)
9796                                                     {
9797                                                       if (((word >> 18) & 0x1) == 0)
9798                                                         {
9799                                                           if (((word >> 19) & 0x1) == 0)
9800                                                             {
9801                                                               /* 33222222222211111111110000000000
9802                                                                  10987654321098765432109876543210
9803                                                                  000001x1xx1x0001100xxxxxxxxxxxxx
9804                                                                  compact.  */
9805                                                               return 1349;
9806                                                             }
9807                                                           else
9808                                                             {
9809                                                               /* 33222222222211111111110000000000
9810                                                                  10987654321098765432109876543210
9811                                                                  000001x1xx1x1001100xxxxxxxxxxxxx
9812                                                                  clastb.  */
9813                                                               return 1311;
9814                                                             }
9815                                                         }
9816                                                       else
9817                                                         {
9818                                                           if (((word >> 19) & 0x1) == 0)
9819                                                             {
9820                                                               /* 33222222222211111111110000000000
9821                                                                  10987654321098765432109876543210
9822                                                                  000001x1xx1x0101100xxxxxxxxxxxxx
9823                                                                  revh.  */
9824                                                               return 1803;
9825                                                             }
9826                                                           else
9827                                                             {
9828                                                               /* 33222222222211111111110000000000
9829                                                                  10987654321098765432109876543210
9830                                                                  000001x1xx1x1101100xxxxxxxxxxxxx
9831                                                                  splice.  */
9832                                                               return 2159;
9833                                                             }
9834                                                         }
9835                                                     }
9836                                                   else
9837                                                     {
9838                                                       if (((word >> 18) & 0x1) == 0)
9839                                                         {
9840                                                           if (((word >> 19) & 0x1) == 0)
9841                                                             {
9842                                                               /* 33222222222211111111110000000000
9843                                                                  10987654321098765432109876543210
9844                                                                  000001x1xx1x0011100xxxxxxxxxxxxx
9845                                                                  lastb.  */
9846                                                               return 1498;
9847                                                             }
9848                                                           else
9849                                                             {
9850                                                               /* 33222222222211111111110000000000
9851                                                                  10987654321098765432109876543210
9852                                                                  000001x1xx1x1011100xxxxxxxxxxxxx
9853                                                                  clastb.  */
9854                                                               return 1312;
9855                                                             }
9856                                                         }
9857                                                       else
9858                                                         {
9859                                                           /* 33222222222211111111110000000000
9860                                                              10987654321098765432109876543210
9861                                                              000001x1xx1xx111100xxxxxxxxxxxxx
9862                                                              rbit.  */
9863                                                           return 1795;
9864                                                         }
9865                                                     }
9866                                                 }
9867                                             }
9868                                         }
9869                                       else
9870                                         {
9871                                           if (((word >> 15) & 0x1) == 0)
9872                                             {
9873                                               if (((word >> 10) & 0x1) == 0)
9874                                                 {
9875                                                   if (((word >> 11) & 0x1) == 0)
9876                                                     {
9877                                                       if (((word >> 12) & 0x1) == 0)
9878                                                         {
9879                                                           /* 33222222222211111111110000000000
9880                                                              10987654321098765432109876543210
9881                                                              000001x1xx1xxxxx001000xxxxxxxxxx
9882                                                              dup.  */
9883                                                           return 1365;
9884                                                         }
9885                                                       else
9886                                                         {
9887                                                           /* 33222222222211111111110000000000
9888                                                              10987654321098765432109876543210
9889                                                              000001x1xx1xxxxx001100xxxxxxxxxx
9890                                                              tbl.  */
9891                                                           return 1952;
9892                                                         }
9893                                                     }
9894                                                   else
9895                                                     {
9896                                                       if (((word >> 12) & 0x1) == 0)
9897                                                         {
9898                                                           /* 33222222222211111111110000000000
9899                                                              10987654321098765432109876543210
9900                                                              000001x1xx1xxxxx001010xxxxxxxxxx
9901                                                              tbl.  */
9902                                                           return 2248;
9903                                                         }
9904                                                       else
9905                                                         {
9906                                                           if (((word >> 16) & 0x1) == 0)
9907                                                             {
9908                                                               if (((word >> 17) & 0x1) == 0)
9909                                                                 {
9910                                                                   if (((word >> 18) & 0x1) == 0)
9911                                                                     {
9912                                                                       if (((word >> 19) & 0x1) == 0)
9913                                                                         {
9914                                                                           if (((word >> 20) & 0x1) == 0)
9915                                                                             {
9916                                                                               /* 33222222222211111111110000000000
9917                                                                                  10987654321098765432109876543210
9918                                                                                  000001x1xx100000001110xxxxxxxxxx
9919                                                                                  dup.  */
9920                                                                               return 1364;
9921                                                                             }
9922                                                                           else
9923                                                                             {
9924                                                                               /* 33222222222211111111110000000000
9925                                                                                  10987654321098765432109876543210
9926                                                                                  000001x1xx110000001110xxxxxxxxxx
9927                                                                                  sunpklo.  */
9928                                                                               return 1948;
9929                                                                             }
9930                                                                         }
9931                                                                       else
9932                                                                         {
9933                                                                           /* 33222222222211111111110000000000
9934                                                                              10987654321098765432109876543210
9935                                                                              000001x1xx1x1000001110xxxxxxxxxx
9936                                                                              rev.  */
9937                                                                           return 1801;
9938                                                                         }
9939                                                                     }
9940                                                                   else
9941                                                                     {
9942                                                                       if (((word >> 20) & 0x1) == 0)
9943                                                                         {
9944                                                                           /* 33222222222211111111110000000000
9945                                                                              10987654321098765432109876543210
9946                                                                              000001x1xx10x100001110xxxxxxxxxx
9947                                                                              insr.  */
9948                                                                           return 1493;
9949                                                                         }
9950                                                                       else
9951                                                                         {
9952                                                                           /* 33222222222211111111110000000000
9953                                                                              10987654321098765432109876543210
9954                                                                              000001x1xx11x100001110xxxxxxxxxx
9955                                                                              insr.  */
9956                                                                           return 1494;
9957                                                                         }
9958                                                                     }
9959                                                                 }
9960                                                               else
9961                                                                 {
9962                                                                   /* 33222222222211111111110000000000
9963                                                                      10987654321098765432109876543210
9964                                                                      000001x1xx1xxx10001110xxxxxxxxxx
9965                                                                      uunpklo.  */
9966                                                                   return 2011;
9967                                                                 }
9968                                                             }
9969                                                           else
9970                                                             {
9971                                                               if (((word >> 17) & 0x1) == 0)
9972                                                                 {
9973                                                                   /* 33222222222211111111110000000000
9974                                                                      10987654321098765432109876543210
9975                                                                      000001x1xx1xxx01001110xxxxxxxxxx
9976                                                                      sunpkhi.  */
9977                                                                   return 1947;
9978                                                                 }
9979                                                               else
9980                                                                 {
9981                                                                   /* 33222222222211111111110000000000
9982                                                                      10987654321098765432109876543210
9983                                                                      000001x1xx1xxx11001110xxxxxxxxxx
9984                                                                      uunpkhi.  */
9985                                                                   return 2010;
9986                                                                 }
9987                                                             }
9988                                                         }
9989                                                     }
9990                                                 }
9991                                               else
9992                                                 {
9993                                                   /* 33222222222211111111110000000000
9994                                                      10987654321098765432109876543210
9995                                                      000001x1xx1xxxxx001xx1xxxxxxxxxx
9996                                                      tbx.  */
9997                                                   return 2249;
9998                                                 }
9999                                             }
10000                                           else
10001                                             {
10002                                               if (((word >> 16) & 0x1) == 0)
10003                                                 {
10004                                                   if (((word >> 19) & 0x1) == 0)
10005                                                     {
10006                                                       if (((word >> 20) & 0x1) == 0)
10007                                                         {
10008                                                           /* 33222222222211111111110000000000
10009                                                              10987654321098765432109876543210
10010                                                              000001x1xx100xx0101xxxxxxxxxxxxx
10011                                                              lasta.  */
10012                                                           return 1495;
10013                                                         }
10014                                                       else
10015                                                         {
10016                                                           /* 33222222222211111111110000000000
10017                                                              10987654321098765432109876543210
10018                                                              000001x1xx110xx0101xxxxxxxxxxxxx
10019                                                              clasta.  */
10020                                                           return 1310;
10021                                                         }
10022                                                     }
10023                                                   else
10024                                                     {
10025                                                       /* 33222222222211111111110000000000
10026                                                          10987654321098765432109876543210
10027                                                          000001x1xx1x1xx0101xxxxxxxxxxxxx
10028                                                          cpy.  */
10029                                                       return 1351;
10030                                                     }
10031                                                 }
10032                                               else
10033                                                 {
10034                                                   if (((word >> 20) & 0x1) == 0)
10035                                                     {
10036                                                       /* 33222222222211111111110000000000
10037                                                          10987654321098765432109876543210
10038                                                          000001x1xx10xxx1101xxxxxxxxxxxxx
10039                                                          lastb.  */
10040                                                       return 1497;
10041                                                     }
10042                                                   else
10043                                                     {
10044                                                       /* 33222222222211111111110000000000
10045                                                          10987654321098765432109876543210
10046                                                          000001x1xx11xxx1101xxxxxxxxxxxxx
10047                                                          clastb.  */
10048                                                       return 1313;
10049                                                     }
10050                                                 }
10051                                             }
10052                                         }
10053                                     }
10054                                   else
10055                                     {
10056                                       if (((word >> 15) & 0x1) == 0)
10057                                         {
10058                                           if (((word >> 10) & 0x1) == 0)
10059                                             {
10060                                               if (((word >> 11) & 0x1) == 0)
10061                                                 {
10062                                                   if (((word >> 12) & 0x1) == 0)
10063                                                     {
10064                                                       if (((word >> 13) & 0x1) == 0)
10065                                                         {
10066                                                           if (((word >> 20) & 0x1) == 0)
10067                                                             {
10068                                                               /* 33222222222211111111110000000000
10069                                                                  10987654321098765432109876543210
10070                                                                  000001x1xx10xxxx010000xxxxxxxxxx
10071                                                                  zip1.  */
10072                                                               return 2028;
10073                                                             }
10074                                                           else
10075                                                             {
10076                                                               if (((word >> 16) & 0x1) == 0)
10077                                                                 {
10078                                                                   if (((word >> 18) & 0x1) == 0)
10079                                                                     {
10080                                                                       /* 33222222222211111111110000000000
10081                                                                          10987654321098765432109876543210
10082                                                                          000001x1xx11x0x0010000xxxxxxxxxx
10083                                                                          punpklo.  */
10084                                                                       return 1794;
10085                                                                     }
10086                                                                   else
10087                                                                     {
10088                                                                       /* 33222222222211111111110000000000
10089                                                                          10987654321098765432109876543210
10090                                                                          000001x1xx11x1x0010000xxxxxxxxxx
10091                                                                          rev.  */
10092                                                                       return 1800;
10093                                                                     }
10094                                                                 }
10095                                                               else
10096                                                                 {
10097                                                                   /* 33222222222211111111110000000000
10098                                                                      10987654321098765432109876543210
10099                                                                      000001x1xx11xxx1010000xxxxxxxxxx
10100                                                                      punpkhi.  */
10101                                                                   return 1793;
10102                                                                 }
10103                                                             }
10104                                                         }
10105                                                       else
10106                                                         {
10107                                                           /* 33222222222211111111110000000000
10108                                                              10987654321098765432109876543210
10109                                                              000001x1xx1xxxxx011000xxxxxxxxxx
10110                                                              zip1.  */
10111                                                           return 2029;
10112                                                         }
10113                                                     }
10114                                                   else
10115                                                     {
10116                                                       if (((word >> 13) & 0x1) == 0)
10117                                                         {
10118                                                           /* 33222222222211111111110000000000
10119                                                              10987654321098765432109876543210
10120                                                              000001x1xx1xxxxx010100xxxxxxxxxx
10121                                                              trn1.  */
10122                                                           return 1953;
10123                                                         }
10124                                                       else
10125                                                         {
10126                                                           /* 33222222222211111111110000000000
10127                                                              10987654321098765432109876543210
10128                                                              000001x1xx1xxxxx011100xxxxxxxxxx
10129                                                              trn1.  */
10130                                                           return 1954;
10131                                                         }
10132                                                     }
10133                                                 }
10134                                               else
10135                                                 {
10136                                                   if (((word >> 13) & 0x1) == 0)
10137                                                     {
10138                                                       /* 33222222222211111111110000000000
10139                                                          10987654321098765432109876543210
10140                                                          000001x1xx1xxxxx010x10xxxxxxxxxx
10141                                                          uzp1.  */
10142                                                       return 2015;
10143                                                     }
10144                                                   else
10145                                                     {
10146                                                       /* 33222222222211111111110000000000
10147                                                          10987654321098765432109876543210
10148                                                          000001x1xx1xxxxx011x10xxxxxxxxxx
10149                                                          uzp1.  */
10150                                                       return 2016;
10151                                                     }
10152                                                 }
10153                                             }
10154                                           else
10155                                             {
10156                                               if (((word >> 11) & 0x1) == 0)
10157                                                 {
10158                                                   if (((word >> 12) & 0x1) == 0)
10159                                                     {
10160                                                       if (((word >> 13) & 0x1) == 0)
10161                                                         {
10162                                                           /* 33222222222211111111110000000000
10163                                                              10987654321098765432109876543210
10164                                                              000001x1xx1xxxxx010001xxxxxxxxxx
10165                                                              zip2.  */
10166                                                           return 2030;
10167                                                         }
10168                                                       else
10169                                                         {
10170                                                           /* 33222222222211111111110000000000
10171                                                              10987654321098765432109876543210
10172                                                              000001x1xx1xxxxx011001xxxxxxxxxx
10173                                                              zip2.  */
10174                                                           return 2031;
10175                                                         }
10176                                                     }
10177                                                   else
10178                                                     {
10179                                                       if (((word >> 13) & 0x1) == 0)
10180                                                         {
10181                                                           /* 33222222222211111111110000000000
10182                                                              10987654321098765432109876543210
10183                                                              000001x1xx1xxxxx010101xxxxxxxxxx
10184                                                              trn2.  */
10185                                                           return 1955;
10186                                                         }
10187                                                       else
10188                                                         {
10189                                                           /* 33222222222211111111110000000000
10190                                                              10987654321098765432109876543210
10191                                                              000001x1xx1xxxxx011101xxxxxxxxxx
10192                                                              trn2.  */
10193                                                           return 1956;
10194                                                         }
10195                                                     }
10196                                                 }
10197                                               else
10198                                                 {
10199                                                   if (((word >> 13) & 0x1) == 0)
10200                                                     {
10201                                                       /* 33222222222211111111110000000000
10202                                                          10987654321098765432109876543210
10203                                                          000001x1xx1xxxxx010x11xxxxxxxxxx
10204                                                          uzp2.  */
10205                                                       return 2017;
10206                                                     }
10207                                                   else
10208                                                     {
10209                                                       /* 33222222222211111111110000000000
10210                                                          10987654321098765432109876543210
10211                                                          000001x1xx1xxxxx011x11xxxxxxxxxx
10212                                                          uzp2.  */
10213                                                       return 2018;
10214                                                     }
10215                                                 }
10216                                             }
10217                                         }
10218                                       else
10219                                         {
10220                                           /* 33222222222211111111110000000000
10221                                              10987654321098765432109876543210
10222                                              000001x1xx1xxxxx11xxxxxxxxxxxxxx
10223                                              sel.  */
10224                                           return 1819;
10225                                         }
10226                                     }
10227                                 }
10228                             }
10229                           else
10230                             {
10231                               if (((word >> 13) & 0x1) == 0)
10232                                 {
10233                                   if (((word >> 14) & 0x1) == 0)
10234                                     {
10235                                       if (((word >> 15) & 0x1) == 0)
10236                                         {
10237                                           if (((word >> 22) & 0x1) == 0)
10238                                             {
10239                                               /* 33222222222211111111110000000000
10240                                                  10987654321098765432109876543210
10241                                                  100001x1x0xxxxxx000xxxxxxxxxxxxx
10242                                                  ldr.  */
10243                                               return 1723;
10244                                             }
10245                                           else
10246                                             {
10247                                               /* 33222222222211111111110000000000
10248                                                  10987654321098765432109876543210
10249                                                  100001x1x1xxxxxx000xxxxxxxxxxxxx
10250                                                  prfb.  */
10251                                               return 1767;
10252                                             }
10253                                         }
10254                                       else
10255                                         {
10256                                           if (((word >> 23) & 0x1) == 0)
10257                                             {
10258                                               /* 33222222222211111111110000000000
10259                                                  10987654321098765432109876543210
10260                                                  100001x10xxxxxxx100xxxxxxxxxxxxx
10261                                                  ld1rsh.  */
10262                                               return 1552;
10263                                             }
10264                                           else
10265                                             {
10266                                               /* 33222222222211111111110000000000
10267                                                  10987654321098765432109876543210
10268                                                  100001x11xxxxxxx100xxxxxxxxxxxxx
10269                                                  ld1rsb.  */
10270                                               return 1549;
10271                                             }
10272                                         }
10273                                     }
10274                                   else
10275                                     {
10276                                       if (((word >> 15) & 0x1) == 0)
10277                                         {
10278                                           if (((word >> 23) & 0x1) == 0)
10279                                             {
10280                                               if (((word >> 21) & 0x1) == 0)
10281                                                 {
10282                                                   /* 33222222222211111111110000000000
10283                                                      10987654321098765432109876543210
10284                                                      100001x10x0xxxxx010xxxxxxxxxxxxx
10285                                                      ld1w.  */
10286                                                   return 1587;
10287                                                 }
10288                                               else
10289                                                 {
10290                                                   /* 33222222222211111111110000000000
10291                                                      10987654321098765432109876543210
10292                                                      100001x10x1xxxxx010xxxxxxxxxxxxx
10293                                                      ld1w.  */
10294                                                   return 1588;
10295                                                 }
10296                                             }
10297                                           else
10298                                             {
10299                                               if (((word >> 22) & 0x1) == 0)
10300                                                 {
10301                                                   /* 33222222222211111111110000000000
10302                                                      10987654321098765432109876543210
10303                                                      100001x110xxxxxx010xxxxxxxxxxxxx
10304                                                      ldr.  */
10305                                                   return 1724;
10306                                                 }
10307                                               else
10308                                                 {
10309                                                   /* 33222222222211111111110000000000
10310                                                      10987654321098765432109876543210
10311                                                      100001x111xxxxxx010xxxxxxxxxxxxx
10312                                                      prfw.  */
10313                                                   return 1788;
10314                                                 }
10315                                             }
10316                                         }
10317                                       else
10318                                         {
10319                                           if (((word >> 22) & 0x1) == 0)
10320                                             {
10321                                               if (((word >> 21) & 0x1) == 0)
10322                                                 {
10323                                                   if (((word >> 23) & 0x1) == 0)
10324                                                     {
10325                                                       /* 33222222222211111111110000000000
10326                                                          10987654321098765432109876543210
10327                                                          100001x1000xxxxx110xxxxxxxxxxxxx
10328                                                          prfw.  */
10329                                                       return 1784;
10330                                                     }
10331                                                   else
10332                                                     {
10333                                                       /* 33222222222211111111110000000000
10334                                                          10987654321098765432109876543210
10335                                                          100001x1100xxxxx110xxxxxxxxxxxxx
10336                                                          prfd.  */
10337                                                       return 1770;
10338                                                     }
10339                                                 }
10340                                               else
10341                                                 {
10342                                                   /* 33222222222211111111110000000000
10343                                                      10987654321098765432109876543210
10344                                                      100001x1x01xxxxx110xxxxxxxxxxxxx
10345                                                      ld1w.  */
10346                                                   return 1595;
10347                                                 }
10348                                             }
10349                                           else
10350                                             {
10351                                               if (((word >> 23) & 0x1) == 0)
10352                                                 {
10353                                                   /* 33222222222211111111110000000000
10354                                                      10987654321098765432109876543210
10355                                                      100001x101xxxxxx110xxxxxxxxxxxxx
10356                                                      ld1rw.  */
10357                                                   return 1555;
10358                                                 }
10359                                               else
10360                                                 {
10361                                                   /* 33222222222211111111110000000000
10362                                                      10987654321098765432109876543210
10363                                                      100001x111xxxxxx110xxxxxxxxxxxxx
10364                                                      ld1rsb.  */
10365                                                   return 1551;
10366                                                 }
10367                                             }
10368                                         }
10369                                     }
10370                                 }
10371                               else
10372                                 {
10373                                   if (((word >> 14) & 0x1) == 0)
10374                                     {
10375                                       if (((word >> 15) & 0x1) == 0)
10376                                         {
10377                                           /* 33222222222211111111110000000000
10378                                              10987654321098765432109876543210
10379                                              100001x1xxxxxxxx001xxxxxxxxxxxxx
10380                                              prfh.  */
10381                                           return 1781;
10382                                         }
10383                                       else
10384                                         {
10385                                           if (((word >> 22) & 0x1) == 0)
10386                                             {
10387                                               /* 33222222222211111111110000000000
10388                                                  10987654321098765432109876543210
10389                                                  100001x1x0xxxxxx101xxxxxxxxxxxxx
10390                                                  ldnt1w.  */
10391                                               return 2095;
10392                                             }
10393                                           else
10394                                             {
10395                                               if (((word >> 23) & 0x1) == 0)
10396                                                 {
10397                                                   /* 33222222222211111111110000000000
10398                                                      10987654321098765432109876543210
10399                                                      100001x101xxxxxx101xxxxxxxxxxxxx
10400                                                      ld1rsh.  */
10401                                                   return 1553;
10402                                                 }
10403                                               else
10404                                                 {
10405                                                   /* 33222222222211111111110000000000
10406                                                      10987654321098765432109876543210
10407                                                      100001x111xxxxxx101xxxxxxxxxxxxx
10408                                                      ld1rsb.  */
10409                                                   return 1550;
10410                                                 }
10411                                             }
10412                                         }
10413                                     }
10414                                   else
10415                                     {
10416                                       if (((word >> 15) & 0x1) == 0)
10417                                         {
10418                                           if (((word >> 23) & 0x1) == 0)
10419                                             {
10420                                               if (((word >> 21) & 0x1) == 0)
10421                                                 {
10422                                                   /* 33222222222211111111110000000000
10423                                                      10987654321098765432109876543210
10424                                                      100001x10x0xxxxx011xxxxxxxxxxxxx
10425                                                      ldff1w.  */
10426                                                   return 1687;
10427                                                 }
10428                                               else
10429                                                 {
10430                                                   /* 33222222222211111111110000000000
10431                                                      10987654321098765432109876543210
10432                                                      100001x10x1xxxxx011xxxxxxxxxxxxx
10433                                                      ldff1w.  */
10434                                                   return 1688;
10435                                                 }
10436                                             }
10437                                           else
10438                                             {
10439                                               /* 33222222222211111111110000000000
10440                                                  10987654321098765432109876543210
10441                                                  100001x11xxxxxxx011xxxxxxxxxxxxx
10442                                                  prfd.  */
10443                                               return 1774;
10444                                             }
10445                                         }
10446                                       else
10447                                         {
10448                                           if (((word >> 22) & 0x1) == 0)
10449                                             {
10450                                               if (((word >> 21) & 0x1) == 0)
10451                                                 {
10452                                                   if (((word >> 23) & 0x1) == 0)
10453                                                     {
10454                                                       /* 33222222222211111111110000000000
10455                                                          10987654321098765432109876543210
10456                                                          100001x1000xxxxx111xxxxxxxxxxxxx
10457                                                          prfw.  */
10458                                                       return 1787;
10459                                                     }
10460                                                   else
10461                                                     {
10462                                                       /* 33222222222211111111110000000000
10463                                                          10987654321098765432109876543210
10464                                                          100001x1100xxxxx111xxxxxxxxxxxxx
10465                                                          prfd.  */
10466                                                       return 1773;
10467                                                     }
10468                                                 }
10469                                               else
10470                                                 {
10471                                                   /* 33222222222211111111110000000000
10472                                                      10987654321098765432109876543210
10473                                                      100001x1x01xxxxx111xxxxxxxxxxxxx
10474                                                      ldff1w.  */
10475                                                   return 1697;
10476                                                 }
10477                                             }
10478                                           else
10479                                             {
10480                                               if (((word >> 23) & 0x1) == 0)
10481                                                 {
10482                                                   /* 33222222222211111111110000000000
10483                                                      10987654321098765432109876543210
10484                                                      100001x101xxxxxx111xxxxxxxxxxxxx
10485                                                      ld1rw.  */
10486                                                   return 1556;
10487                                                 }
10488                                               else
10489                                                 {
10490                                                   /* 33222222222211111111110000000000
10491                                                      10987654321098765432109876543210
10492                                                      100001x111xxxxxx111xxxxxxxxxxxxx
10493                                                      ld1rd.  */
10494                                                   return 1537;
10495                                                 }
10496                                             }
10497                                         }
10498                                     }
10499                                 }
10500                             }
10501                         }
10502                       else
10503                         {
10504                           if (((word >> 13) & 0x1) == 0)
10505                             {
10506                               if (((word >> 14) & 0x1) == 0)
10507                                 {
10508                                   if (((word >> 15) & 0x1) == 0)
10509                                     {
10510                                       if (((word >> 21) & 0x1) == 0)
10511                                         {
10512                                           if (((word >> 31) & 0x1) == 0)
10513                                             {
10514                                               if (((word >> 10) & 0x1) == 0)
10515                                                 {
10516                                                   if (((word >> 11) & 0x1) == 0)
10517                                                     {
10518                                                       if (((word >> 12) & 0x1) == 0)
10519                                                         {
10520                                                           /* 33222222222211111111110000000000
10521                                                              10987654321098765432109876543210
10522                                                              010001x1xx0xxxxx000000xxxxxxxxxx
10523                                                              saddlb.  */
10524                                                           return 2125;
10525                                                         }
10526                                                       else
10527                                                         {
10528                                                           /* 33222222222211111111110000000000
10529                                                              10987654321098765432109876543210
10530                                                              010001x1xx0xxxxx000100xxxxxxxxxx
10531                                                              ssublb.  */
10532                                                           return 2232;
10533                                                         }
10534                                                     }
10535                                                   else
10536                                                     {
10537                                                       if (((word >> 12) & 0x1) == 0)
10538                                                         {
10539                                                           /* 33222222222211111111110000000000
10540                                                              10987654321098765432109876543210
10541                                                              010001x1xx0xxxxx000010xxxxxxxxxx
10542                                                              uaddlb.  */
10543                                                           return 2256;
10544                                                         }
10545                                                       else
10546                                                         {
10547                                                           /* 33222222222211111111110000000000
10548                                                              10987654321098765432109876543210
10549                                                              010001x1xx0xxxxx000110xxxxxxxxxx
10550                                                              usublb.  */
10551                                                           return 2309;
10552                                                         }
10553                                                     }
10554                                                 }
10555                                               else
10556                                                 {
10557                                                   if (((word >> 11) & 0x1) == 0)
10558                                                     {
10559                                                       if (((word >> 12) & 0x1) == 0)
10560                                                         {
10561                                                           /* 33222222222211111111110000000000
10562                                                              10987654321098765432109876543210
10563                                                              010001x1xx0xxxxx000001xxxxxxxxxx
10564                                                              saddlt.  */
10565                                                           return 2127;
10566                                                         }
10567                                                       else
10568                                                         {
10569                                                           /* 33222222222211111111110000000000
10570                                                              10987654321098765432109876543210
10571                                                              010001x1xx0xxxxx000101xxxxxxxxxx
10572                                                              ssublt.  */
10573                                                           return 2234;
10574                                                         }
10575                                                     }
10576                                                   else
10577                                                     {
10578                                                       if (((word >> 12) & 0x1) == 0)
10579                                                         {
10580                                                           /* 33222222222211111111110000000000
10581                                                              10987654321098765432109876543210
10582                                                              010001x1xx0xxxxx000011xxxxxxxxxx
10583                                                              uaddlt.  */
10584                                                           return 2257;
10585                                                         }
10586                                                       else
10587                                                         {
10588                                                           /* 33222222222211111111110000000000
10589                                                              10987654321098765432109876543210
10590                                                              010001x1xx0xxxxx000111xxxxxxxxxx
10591                                                              usublt.  */
10592                                                           return 2310;
10593                                                         }
10594                                                     }
10595                                                 }
10596                                             }
10597                                           else
10598                                             {
10599                                               /* 33222222222211111111110000000000
10600                                                  10987654321098765432109876543210
10601                                                  110001x1xx0xxxxx000xxxxxxxxxxxxx
10602                                                  ld1sw.  */
10603                                               return 1581;
10604                                             }
10605                                         }
10606                                       else
10607                                         {
10608                                           if (((word >> 31) & 0x1) == 0)
10609                                             {
10610                                               if (((word >> 10) & 0x1) == 0)
10611                                                 {
10612                                                   if (((word >> 11) & 0x1) == 0)
10613                                                     {
10614                                                       if (((word >> 12) & 0x1) == 0)
10615                                                         {
10616                                                           /* 33222222222211111111110000000000
10617                                                              10987654321098765432109876543210
10618                                                              010001x1xx1xxxxx000000xxxxxxxxxx
10619                                                              sqshrunb.  */
10620                                                           return 2215;
10621                                                         }
10622                                                       else
10623                                                         {
10624                                                           /* 33222222222211111111110000000000
10625                                                              10987654321098765432109876543210
10626                                                              010001x1xx1xxxxx000100xxxxxxxxxx
10627                                                              shrnb.  */
10628                                                           return 2133;
10629                                                         }
10630                                                     }
10631                                                   else
10632                                                     {
10633                                                       if (((word >> 12) & 0x1) == 0)
10634                                                         {
10635                                                           /* 33222222222211111111110000000000
10636                                                              10987654321098765432109876543210
10637                                                              010001x1xx1xxxxx000010xxxxxxxxxx
10638                                                              sqrshrunb.  */
10639                                                           return 2207;
10640                                                         }
10641                                                       else
10642                                                         {
10643                                                           /* 33222222222211111111110000000000
10644                                                              10987654321098765432109876543210
10645                                                              010001x1xx1xxxxx000110xxxxxxxxxx
10646                                                              rshrnb.  */
10647                                                           return 2115;
10648                                                         }
10649                                                     }
10650                                                 }
10651                                               else
10652                                                 {
10653                                                   if (((word >> 11) & 0x1) == 0)
10654                                                     {
10655                                                       if (((word >> 12) & 0x1) == 0)
10656                                                         {
10657                                                           /* 33222222222211111111110000000000
10658                                                              10987654321098765432109876543210
10659                                                              010001x1xx1xxxxx000001xxxxxxxxxx
10660                                                              sqshrunt.  */
10661                                                           return 2216;
10662                                                         }
10663                                                       else
10664                                                         {
10665                                                           /* 33222222222211111111110000000000
10666                                                              10987654321098765432109876543210
10667                                                              010001x1xx1xxxxx000101xxxxxxxxxx
10668                                                              shrnt.  */
10669                                                           return 2134;
10670                                                         }
10671                                                     }
10672                                                   else
10673                                                     {
10674                                                       if (((word >> 12) & 0x1) == 0)
10675                                                         {
10676                                                           /* 33222222222211111111110000000000
10677                                                              10987654321098765432109876543210
10678                                                              010001x1xx1xxxxx000011xxxxxxxxxx
10679                                                              sqrshrunt.  */
10680                                                           return 2208;
10681                                                         }
10682                                                       else
10683                                                         {
10684                                                           /* 33222222222211111111110000000000
10685                                                              10987654321098765432109876543210
10686                                                              010001x1xx1xxxxx000111xxxxxxxxxx
10687                                                              rshrnt.  */
10688                                                           return 2116;
10689                                                         }
10690                                                     }
10691                                                 }
10692                                             }
10693                                           else
10694                                             {
10695                                               /* 33222222222211111111110000000000
10696                                                  10987654321098765432109876543210
10697                                                  110001x1xx1xxxxx000xxxxxxxxxxxxx
10698                                                  ld1sw.  */
10699                                               return 1582;
10700                                             }
10701                                         }
10702                                     }
10703                                   else
10704                                     {
10705                                       if (((word >> 21) & 0x1) == 0)
10706                                         {
10707                                           if (((word >> 31) & 0x1) == 0)
10708                                             {
10709                                               if (((word >> 10) & 0x1) == 0)
10710                                                 {
10711                                                   if (((word >> 11) & 0x1) == 0)
10712                                                     {
10713                                                       if (((word >> 12) & 0x1) == 0)
10714                                                         {
10715                                                           /* 33222222222211111111110000000000
10716                                                              10987654321098765432109876543210
10717                                                              010001x1xx0xxxxx100000xxxxxxxxxx
10718                                                              saddlbt.  */
10719                                                           return 2126;
10720                                                         }
10721                                                       else
10722                                                         {
10723                                                           /* 33222222222211111111110000000000
10724                                                              10987654321098765432109876543210
10725                                                              010001x1xx0xxxxx100100xxxxxxxxxx
10726                                                              eorbt.  */
10727                                                           return 2062;
10728                                                         }
10729                                                     }
10730                                                   else
10731                                                     {
10732                                                       /* 33222222222211111111110000000000
10733                                                          10987654321098765432109876543210
10734                                                          010001x1xx0xxxxx100x10xxxxxxxxxx
10735                                                          ssublbt.  */
10736                                                       return 2233;
10737                                                     }
10738                                                 }
10739                                               else
10740                                                 {
10741                                                   if (((word >> 11) & 0x1) == 0)
10742                                                     {
10743                                                       /* 33222222222211111111110000000000
10744                                                          10987654321098765432109876543210
10745                                                          010001x1xx0xxxxx100x01xxxxxxxxxx
10746                                                          eortb.  */
10747                                                       return 2063;
10748                                                     }
10749                                                   else
10750                                                     {
10751                                                       /* 33222222222211111111110000000000
10752                                                          10987654321098765432109876543210
10753                                                          010001x1xx0xxxxx100x11xxxxxxxxxx
10754                                                          ssubltb.  */
10755                                                       return 2235;
10756                                                     }
10757                                                 }
10758                                             }
10759                                           else
10760                                             {
10761                                               if (((word >> 22) & 0x1) == 0)
10762                                                 {
10763                                                   /* 33222222222211111111110000000000
10764                                                      10987654321098765432109876543210
10765                                                      110001x1x00xxxxx100xxxxxxxxxxxxx
10766                                                      ldnt1sw.  */
10767                                                   return 2094;
10768                                                 }
10769                                               else
10770                                                 {
10771                                                   /* 33222222222211111111110000000000
10772                                                      10987654321098765432109876543210
10773                                                      110001x1x10xxxxx100xxxxxxxxxxxxx
10774                                                      ld1sw.  */
10775                                                   return 1583;
10776                                                 }
10777                                             }
10778                                         }
10779                                       else
10780                                         {
10781                                           if (((word >> 31) & 0x1) == 0)
10782                                             {
10783                                               if (((word >> 4) & 0x1) == 0)
10784                                                 {
10785                                                   /* 33222222222211111111110000000000
10786                                                      10987654321098765432109876543210
10787                                                      010001x1xx1xxxxx100xxxxxxxx0xxxx
10788                                                      match.  */
10789                                                   return 2097;
10790                                                 }
10791                                               else
10792                                                 {
10793                                                   /* 33222222222211111111110000000000
10794                                                      10987654321098765432109876543210
10795                                                      010001x1xx1xxxxx100xxxxxxxx1xxxx
10796                                                      nmatch.  */
10797                                                   return 2109;
10798                                                 }
10799                                             }
10800                                           else
10801                                             {
10802                                               if (((word >> 22) & 0x1) == 0)
10803                                                 {
10804                                                   /* 33222222222211111111110000000000
10805                                                      10987654321098765432109876543210
10806                                                      110001x1x01xxxxx100xxxxxxxxxxxxx
10807                                                      ld1sw.  */
10808                                                   return 1586;
10809                                                 }
10810                                               else
10811                                                 {
10812                                                   /* 33222222222211111111110000000000
10813                                                      10987654321098765432109876543210
10814                                                      110001x1x11xxxxx100xxxxxxxxxxxxx
10815                                                      ld1sw.  */
10816                                                   return 1584;
10817                                                 }
10818                                             }
10819                                         }
10820                                     }
10821                                 }
10822                               else
10823                                 {
10824                                   if (((word >> 15) & 0x1) == 0)
10825                                     {
10826                                       if (((word >> 21) & 0x1) == 0)
10827                                         {
10828                                           if (((word >> 31) & 0x1) == 0)
10829                                             {
10830                                               if (((word >> 10) & 0x1) == 0)
10831                                                 {
10832                                                   if (((word >> 11) & 0x1) == 0)
10833                                                     {
10834                                                       if (((word >> 12) & 0x1) == 0)
10835                                                         {
10836                                                           /* 33222222222211111111110000000000
10837                                                              10987654321098765432109876543210
10838                                                              010001x1xx0xxxxx010000xxxxxxxxxx
10839                                                              saddwb.  */
10840                                                           return 2128;
10841                                                         }
10842                                                       else
10843                                                         {
10844                                                           /* 33222222222211111111110000000000
10845                                                              10987654321098765432109876543210
10846                                                              010001x1xx0xxxxx010100xxxxxxxxxx
10847                                                              ssubwb.  */
10848                                                           return 2236;
10849                                                         }
10850                                                     }
10851                                                   else
10852                                                     {
10853                                                       if (((word >> 12) & 0x1) == 0)
10854                                                         {
10855                                                           /* 33222222222211111111110000000000
10856                                                              10987654321098765432109876543210
10857                                                              010001x1xx0xxxxx010010xxxxxxxxxx
10858                                                              uaddwb.  */
10859                                                           return 2258;
10860                                                         }
10861                                                       else
10862                                                         {
10863                                                           /* 33222222222211111111110000000000
10864                                                              10987654321098765432109876543210
10865                                                              010001x1xx0xxxxx010110xxxxxxxxxx
10866                                                              usubwb.  */
10867                                                           return 2311;
10868                                                         }
10869                                                     }
10870                                                 }
10871                                               else
10872                                                 {
10873                                                   if (((word >> 11) & 0x1) == 0)
10874                                                     {
10875                                                       if (((word >> 12) & 0x1) == 0)
10876                                                         {
10877                                                           /* 33222222222211111111110000000000
10878                                                              10987654321098765432109876543210
10879                                                              010001x1xx0xxxxx010001xxxxxxxxxx
10880                                                              saddwt.  */
10881                                                           return 2129;
10882                                                         }
10883                                                       else
10884                                                         {
10885                                                           /* 33222222222211111111110000000000
10886                                                              10987654321098765432109876543210
10887                                                              010001x1xx0xxxxx010101xxxxxxxxxx
10888                                                              ssubwt.  */
10889                                                           return 2237;
10890                                                         }
10891                                                     }
10892                                                   else
10893                                                     {
10894                                                       if (((word >> 12) & 0x1) == 0)
10895                                                         {
10896                                                           /* 33222222222211111111110000000000
10897                                                              10987654321098765432109876543210
10898                                                              010001x1xx0xxxxx010011xxxxxxxxxx
10899                                                              uaddwt.  */
10900                                                           return 2259;
10901                                                         }
10902                                                       else
10903                                                         {
10904                                                           /* 33222222222211111111110000000000
10905                                                              10987654321098765432109876543210
10906                                                              010001x1xx0xxxxx010111xxxxxxxxxx
10907                                                              usubwt.  */
10908                                                           return 2312;
10909                                                         }
10910                                                     }
10911                                                 }
10912                                             }
10913                                           else
10914                                             {
10915                                               if (((word >> 23) & 0x1) == 0)
10916                                                 {
10917                                                   /* 33222222222211111111110000000000
10918                                                      10987654321098765432109876543210
10919                                                      110001x10x0xxxxx010xxxxxxxxxxxxx
10920                                                      ld1w.  */
10921                                                   return 1591;
10922                                                 }
10923                                               else
10924                                                 {
10925                                                   /* 33222222222211111111110000000000
10926                                                      10987654321098765432109876543210
10927                                                      110001x11x0xxxxx010xxxxxxxxxxxxx
10928                                                      ld1d.  */
10929                                                   return 1513;
10930                                                 }
10931                                             }
10932                                         }
10933                                       else
10934                                         {
10935                                           if (((word >> 23) & 0x1) == 0)
10936                                             {
10937                                               if (((word >> 31) & 0x1) == 0)
10938                                                 {
10939                                                   if (((word >> 10) & 0x1) == 0)
10940                                                     {
10941                                                       if (((word >> 11) & 0x1) == 0)
10942                                                         {
10943                                                           if (((word >> 12) & 0x1) == 0)
10944                                                             {
10945                                                               /* 33222222222211111111110000000000
10946                                                                  10987654321098765432109876543210
10947                                                                  010001x10x1xxxxx010000xxxxxxxxxx
10948                                                                  sqxtnb.  */
10949                                                               return 2219;
10950                                                             }
10951                                                           else
10952                                                             {
10953                                                               /* 33222222222211111111110000000000
10954                                                                  10987654321098765432109876543210
10955                                                                  010001x10x1xxxxx010100xxxxxxxxxx
10956                                                                  sqxtunb.  */
10957                                                               return 2221;
10958                                                             }
10959                                                         }
10960                                                       else
10961                                                         {
10962                                                           /* 33222222222211111111110000000000
10963                                                              10987654321098765432109876543210
10964                                                              010001x10x1xxxxx010x10xxxxxxxxxx
10965                                                              uqxtnb.  */
10966                                                           return 2296;
10967                                                         }
10968                                                     }
10969                                                   else
10970                                                     {
10971                                                       if (((word >> 11) & 0x1) == 0)
10972                                                         {
10973                                                           if (((word >> 12) & 0x1) == 0)
10974                                                             {
10975                                                               /* 33222222222211111111110000000000
10976                                                                  10987654321098765432109876543210
10977                                                                  010001x10x1xxxxx010001xxxxxxxxxx
10978                                                                  sqxtnt.  */
10979                                                               return 2220;
10980                                                             }
10981                                                           else
10982                                                             {
10983                                                               /* 33222222222211111111110000000000
10984                                                                  10987654321098765432109876543210
10985                                                                  010001x10x1xxxxx010101xxxxxxxxxx
10986                                                                  sqxtunt.  */
10987                                                               return 2222;
10988                                                             }
10989                                                         }
10990                                                       else
10991                                                         {
10992                                                           /* 33222222222211111111110000000000
10993                                                              10987654321098765432109876543210
10994                                                              010001x10x1xxxxx010x11xxxxxxxxxx
10995                                                              uqxtnt.  */
10996                                                           return 2297;
10997                                                         }
10998                                                     }
10999                                                 }
11000                                               else
11001                                                 {
11002                                                   /* 33222222222211111111110000000000
11003                                                      10987654321098765432109876543210
11004                                                      110001x10x1xxxxx010xxxxxxxxxxxxx
11005                                                      ld1w.  */
11006                                                   return 1592;
11007                                                 }
11008                                             }
11009                                           else
11010                                             {
11011                                               /* 33222222222211111111110000000000
11012                                                  10987654321098765432109876543210
11013                                                  x10001x11x1xxxxx010xxxxxxxxxxxxx
11014                                                  ld1d.  */
11015                                               return 1514;
11016                                             }
11017                                         }
11018                                     }
11019                                   else
11020                                     {
11021                                       if (((word >> 21) & 0x1) == 0)
11022                                         {
11023                                           if (((word >> 31) & 0x1) == 0)
11024                                             {
11025                                               if (((word >> 11) & 0x1) == 0)
11026                                                 {
11027                                                   if (((word >> 10) & 0x1) == 0)
11028                                                     {
11029                                                       if (((word >> 12) & 0x1) == 0)
11030                                                         {
11031                                                           /* 33222222222211111111110000000000
11032                                                              10987654321098765432109876543210
11033                                                              010001x1xx0xxxxx110000xxxxxxxxxx
11034                                                              sabalb.  */
11035                                                           return 2120;
11036                                                         }
11037                                                       else
11038                                                         {
11039                                                           if (((word >> 23) & 0x1) == 0)
11040                                                             {
11041                                                               /* 33222222222211111111110000000000
11042                                                                  10987654321098765432109876543210
11043                                                                  010001x10x0xxxxx110100xxxxxxxxxx
11044                                                                  adclb.  */
11045                                                               return 2045;
11046                                                             }
11047                                                           else
11048                                                             {
11049                                                               /* 33222222222211111111110000000000
11050                                                                  10987654321098765432109876543210
11051                                                                  010001x11x0xxxxx110100xxxxxxxxxx
11052                                                                  sbclb.  */
11053                                                               return 2130;
11054                                                             }
11055                                                         }
11056                                                     }
11057                                                   else
11058                                                     {
11059                                                       if (((word >> 12) & 0x1) == 0)
11060                                                         {
11061                                                           /* 33222222222211111111110000000000
11062                                                              10987654321098765432109876543210
11063                                                              010001x1xx0xxxxx110001xxxxxxxxxx
11064                                                              sabalt.  */
11065                                                           return 2121;
11066                                                         }
11067                                                       else
11068                                                         {
11069                                                           if (((word >> 23) & 0x1) == 0)
11070                                                             {
11071                                                               /* 33222222222211111111110000000000
11072                                                                  10987654321098765432109876543210
11073                                                                  010001x10x0xxxxx110101xxxxxxxxxx
11074                                                                  adclt.  */
11075                                                               return 2046;
11076                                                             }
11077                                                           else
11078                                                             {
11079                                                               /* 33222222222211111111110000000000
11080                                                                  10987654321098765432109876543210
11081                                                                  010001x11x0xxxxx110101xxxxxxxxxx
11082                                                                  sbclt.  */
11083                                                               return 2131;
11084                                                             }
11085                                                         }
11086                                                     }
11087                                                 }
11088                                               else
11089                                                 {
11090                                                   if (((word >> 12) & 0x1) == 0)
11091                                                     {
11092                                                       if (((word >> 10) & 0x1) == 0)
11093                                                         {
11094                                                           /* 33222222222211111111110000000000
11095                                                              10987654321098765432109876543210
11096                                                              010001x1xx0xxxxx110010xxxxxxxxxx
11097                                                              uabalb.  */
11098                                                           return 2251;
11099                                                         }
11100                                                       else
11101                                                         {
11102                                                           /* 33222222222211111111110000000000
11103                                                              10987654321098765432109876543210
11104                                                              010001x1xx0xxxxx110011xxxxxxxxxx
11105                                                              uabalt.  */
11106                                                           return 2252;
11107                                                         }
11108                                                     }
11109                                                   else
11110                                                     {
11111                                                       if (((word >> 16) & 0x1) == 0)
11112                                                         {
11113                                                           /* 33222222222211111111110000000000
11114                                                              10987654321098765432109876543210
11115                                                              010001x1xx0xxxx011011xxxxxxxxxxx
11116                                                              cadd.  */
11117                                                           return 2054;
11118                                                         }
11119                                                       else
11120                                                         {
11121                                                           /* 33222222222211111111110000000000
11122                                                              10987654321098765432109876543210
11123                                                              010001x1xx0xxxx111011xxxxxxxxxxx
11124                                                              sqcadd.  */
11125                                                           return 2162;
11126                                                         }
11127                                                     }
11128                                                 }
11129                                             }
11130                                           else
11131                                             {
11132                                               if (((word >> 22) & 0x1) == 0)
11133                                                 {
11134                                                   if (((word >> 23) & 0x1) == 0)
11135                                                     {
11136                                                       /* 33222222222211111111110000000000
11137                                                          10987654321098765432109876543210
11138                                                          110001x1000xxxxx110xxxxxxxxxxxxx
11139                                                          ldnt1w.  */
11140                                                       return 2096;
11141                                                     }
11142                                                   else
11143                                                     {
11144                                                       /* 33222222222211111111110000000000
11145                                                          10987654321098765432109876543210
11146                                                          110001x1100xxxxx110xxxxxxxxxxxxx
11147                                                          ldnt1d.  */
11148                                                       return 2089;
11149                                                     }
11150                                                 }
11151                                               else
11152                                                 {
11153                                                   if (((word >> 23) & 0x1) == 0)
11154                                                     {
11155                                                       /* 33222222222211111111110000000000
11156                                                          10987654321098765432109876543210
11157                                                          110001x1010xxxxx110xxxxxxxxxxxxx
11158                                                          ld1w.  */
11159                                                       return 1593;
11160                                                     }
11161                                                   else
11162                                                     {
11163                                                       /* 33222222222211111111110000000000
11164                                                          10987654321098765432109876543210
11165                                                          110001x1110xxxxx110xxxxxxxxxxxxx
11166                                                          ld1d.  */
11167                                                       return 1515;
11168                                                     }
11169                                                 }
11170                                             }
11171                                         }
11172                                       else
11173                                         {
11174                                           if (((word >> 23) & 0x1) == 0)
11175                                             {
11176                                               if (((word >> 22) & 0x1) == 0)
11177                                                 {
11178                                                   /* 33222222222211111111110000000000
11179                                                      10987654321098765432109876543210
11180                                                      x10001x1001xxxxx110xxxxxxxxxxxxx
11181                                                      ld1w.  */
11182                                                   return 1598;
11183                                                 }
11184                                               else
11185                                                 {
11186                                                   /* 33222222222211111111110000000000
11187                                                      10987654321098765432109876543210
11188                                                      x10001x1011xxxxx110xxxxxxxxxxxxx
11189                                                      ld1w.  */
11190                                                   return 1594;
11191                                                 }
11192                                             }
11193                                           else
11194                                             {
11195                                               if (((word >> 31) & 0x1) == 0)
11196                                                 {
11197                                                   /* 33222222222211111111110000000000
11198                                                      10987654321098765432109876543210
11199                                                      010001x11x1xxxxx110xxxxxxxxxxxxx
11200                                                      histcnt.  */
11201                                                   return 2085;
11202                                                 }
11203                                               else
11204                                                 {
11205                                                   if (((word >> 22) & 0x1) == 0)
11206                                                     {
11207                                                       /* 33222222222211111111110000000000
11208                                                          10987654321098765432109876543210
11209                                                          110001x1101xxxxx110xxxxxxxxxxxxx
11210                                                          ld1d.  */
11211                                                       return 1518;
11212                                                     }
11213                                                   else
11214                                                     {
11215                                                       /* 33222222222211111111110000000000
11216                                                          10987654321098765432109876543210
11217                                                          110001x1111xxxxx110xxxxxxxxxxxxx
11218                                                          ld1d.  */
11219                                                       return 1516;
11220                                                     }
11221                                                 }
11222                                             }
11223                                         }
11224                                     }
11225                                 }
11226                             }
11227                           else
11228                             {
11229                               if (((word >> 14) & 0x1) == 0)
11230                                 {
11231                                   if (((word >> 15) & 0x1) == 0)
11232                                     {
11233                                       if (((word >> 21) & 0x1) == 0)
11234                                         {
11235                                           if (((word >> 31) & 0x1) == 0)
11236                                             {
11237                                               if (((word >> 10) & 0x1) == 0)
11238                                                 {
11239                                                   if (((word >> 11) & 0x1) == 0)
11240                                                     {
11241                                                       /* 33222222222211111111110000000000
11242                                                          10987654321098765432109876543210
11243                                                          010001x1xx0xxxxx001x00xxxxxxxxxx
11244                                                          sabdlb.  */
11245                                                       return 2122;
11246                                                     }
11247                                                   else
11248                                                     {
11249                                                       /* 33222222222211111111110000000000
11250                                                          10987654321098765432109876543210
11251                                                          010001x1xx0xxxxx001x10xxxxxxxxxx
11252                                                          uabdlb.  */
11253                                                       return 2253;
11254                                                     }
11255                                                 }
11256                                               else
11257                                                 {
11258                                                   if (((word >> 11) & 0x1) == 0)
11259                                                     {
11260                                                       /* 33222222222211111111110000000000
11261                                                          10987654321098765432109876543210
11262                                                          010001x1xx0xxxxx001x01xxxxxxxxxx
11263                                                          sabdlt.  */
11264                                                       return 2123;
11265                                                     }
11266                                                   else
11267                                                     {
11268                                                       /* 33222222222211111111110000000000
11269                                                          10987654321098765432109876543210
11270                                                          010001x1xx0xxxxx001x11xxxxxxxxxx
11271                                                          uabdlt.  */
11272                                                       return 2254;
11273                                                     }
11274                                                 }
11275                                             }
11276                                           else
11277                                             {
11278                                               /* 33222222222211111111110000000000
11279                                                  10987654321098765432109876543210
11280                                                  110001x1xx0xxxxx001xxxxxxxxxxxxx
11281                                                  ldff1sw.  */
11282                                               return 1682;
11283                                             }
11284                                         }
11285                                       else
11286                                         {
11287                                           if (((word >> 31) & 0x1) == 0)
11288                                             {
11289                                               if (((word >> 10) & 0x1) == 0)
11290                                                 {
11291                                                   if (((word >> 11) & 0x1) == 0)
11292                                                     {
11293                                                       if (((word >> 12) & 0x1) == 0)
11294                                                         {
11295                                                           /* 33222222222211111111110000000000
11296                                                              10987654321098765432109876543210
11297                                                              010001x1xx1xxxxx001000xxxxxxxxxx
11298                                                              sqshrnb.  */
11299                                                           return 2213;
11300                                                         }
11301                                                       else
11302                                                         {
11303                                                           /* 33222222222211111111110000000000
11304                                                              10987654321098765432109876543210
11305                                                              010001x1xx1xxxxx001100xxxxxxxxxx
11306                                                              uqshrnb.  */
11307                                                           return 2292;
11308                                                         }
11309                                                     }
11310                                                   else
11311                                                     {
11312                                                       if (((word >> 12) & 0x1) == 0)
11313                                                         {
11314                                                           /* 33222222222211111111110000000000
11315                                                              10987654321098765432109876543210
11316                                                              010001x1xx1xxxxx001010xxxxxxxxxx
11317                                                              sqrshrnb.  */
11318                                                           return 2205;
11319                                                         }
11320                                                       else
11321                                                         {
11322                                                           /* 33222222222211111111110000000000
11323                                                              10987654321098765432109876543210
11324                                                              010001x1xx1xxxxx001110xxxxxxxxxx
11325                                                              uqrshrnb.  */
11326                                                           return 2287;
11327                                                         }
11328                                                     }
11329                                                 }
11330                                               else
11331                                                 {
11332                                                   if (((word >> 11) & 0x1) == 0)
11333                                                     {
11334                                                       if (((word >> 12) & 0x1) == 0)
11335                                                         {
11336                                                           /* 33222222222211111111110000000000
11337                                                              10987654321098765432109876543210
11338                                                              010001x1xx1xxxxx001001xxxxxxxxxx
11339                                                              sqshrnt.  */
11340                                                           return 2214;
11341                                                         }
11342                                                       else
11343                                                         {
11344                                                           /* 33222222222211111111110000000000
11345                                                              10987654321098765432109876543210
11346                                                              010001x1xx1xxxxx001101xxxxxxxxxx
11347                                                              uqshrnt.  */
11348                                                           return 2293;
11349                                                         }
11350                                                     }
11351                                                   else
11352                                                     {
11353                                                       if (((word >> 12) & 0x1) == 0)
11354                                                         {
11355                                                           /* 33222222222211111111110000000000
11356                                                              10987654321098765432109876543210
11357                                                              010001x1xx1xxxxx001011xxxxxxxxxx
11358                                                              sqrshrnt.  */
11359                                                           return 2206;
11360                                                         }
11361                                                       else
11362                                                         {
11363                                                           /* 33222222222211111111110000000000
11364                                                              10987654321098765432109876543210
11365                                                              010001x1xx1xxxxx001111xxxxxxxxxx
11366                                                              uqrshrnt.  */
11367                                                           return 2288;
11368                                                         }
11369                                                     }
11370                                                 }
11371                                             }
11372                                           else
11373                                             {
11374                                               /* 33222222222211111111110000000000
11375                                                  10987654321098765432109876543210
11376                                                  110001x1xx1xxxxx001xxxxxxxxxxxxx
11377                                                  ldff1sw.  */
11378                                               return 1683;
11379                                             }
11380                                         }
11381                                     }
11382                                   else
11383                                     {
11384                                       if (((word >> 21) & 0x1) == 0)
11385                                         {
11386                                           if (((word >> 31) & 0x1) == 0)
11387                                             {
11388                                               if (((word >> 10) & 0x1) == 0)
11389                                                 {
11390                                                   if (((word >> 11) & 0x1) == 0)
11391                                                     {
11392                                                       if (((word >> 12) & 0x1) == 0)
11393                                                         {
11394                                                           /* 33222222222211111111110000000000
11395                                                              10987654321098765432109876543210
11396                                                              010001x1xx0xxxxx101000xxxxxxxxxx
11397                                                              sshllb.  */
11398                                                           return 2229;
11399                                                         }
11400                                                       else
11401                                                         {
11402                                                           /* 33222222222211111111110000000000
11403                                                              10987654321098765432109876543210
11404                                                              010001x1xx0xxxxx101100xxxxxxxxxx
11405                                                              bext.  */
11406                                                           return 2334;
11407                                                         }
11408                                                     }
11409                                                   else
11410                                                     {
11411                                                       if (((word >> 12) & 0x1) == 0)
11412                                                         {
11413                                                           /* 33222222222211111111110000000000
11414                                                              10987654321098765432109876543210
11415                                                              010001x1xx0xxxxx101010xxxxxxxxxx
11416                                                              ushllb.  */
11417                                                           return 2305;
11418                                                         }
11419                                                       else
11420                                                         {
11421                                                           /* 33222222222211111111110000000000
11422                                                              10987654321098765432109876543210
11423                                                              010001x1xx0xxxxx101110xxxxxxxxxx
11424                                                              bgrp.  */
11425                                                           return 2335;
11426                                                         }
11427                                                     }
11428                                                 }
11429                                               else
11430                                                 {
11431                                                   if (((word >> 11) & 0x1) == 0)
11432                                                     {
11433                                                       if (((word >> 12) & 0x1) == 0)
11434                                                         {
11435                                                           /* 33222222222211111111110000000000
11436                                                              10987654321098765432109876543210
11437                                                              010001x1xx0xxxxx101001xxxxxxxxxx
11438                                                              sshllt.  */
11439                                                           return 2230;
11440                                                         }
11441                                                       else
11442                                                         {
11443                                                           /* 33222222222211111111110000000000
11444                                                              10987654321098765432109876543210
11445                                                              010001x1xx0xxxxx101101xxxxxxxxxx
11446                                                              bdep.  */
11447                                                           return 2333;
11448                                                         }
11449                                                     }
11450                                                   else
11451                                                     {
11452                                                       /* 33222222222211111111110000000000
11453                                                          10987654321098765432109876543210
11454                                                          010001x1xx0xxxxx101x11xxxxxxxxxx
11455                                                          ushllt.  */
11456                                                       return 2306;
11457                                                     }
11458                                                 }
11459                                             }
11460                                           else
11461                                             {
11462                                               /* 33222222222211111111110000000000
11463                                                  10987654321098765432109876543210
11464                                                  110001x1xx0xxxxx101xxxxxxxxxxxxx
11465                                                  ldff1sw.  */
11466                                               return 1684;
11467                                             }
11468                                         }
11469                                       else
11470                                         {
11471                                           if (((word >> 22) & 0x1) == 0)
11472                                             {
11473                                               if (((word >> 31) & 0x1) == 0)
11474                                                 {
11475                                                   /* 33222222222211111111110000000000
11476                                                      10987654321098765432109876543210
11477                                                      010001x1x01xxxxx101xxxxxxxxxxxxx
11478                                                      histseg.  */
11479                                                   return 2086;
11480                                                 }
11481                                               else
11482                                                 {
11483                                                   /* 33222222222211111111110000000000
11484                                                      10987654321098765432109876543210
11485                                                      110001x1x01xxxxx101xxxxxxxxxxxxx
11486                                                      ldff1sw.  */
11487                                                   return 1686;
11488                                                 }
11489                                             }
11490                                           else
11491                                             {
11492                                               /* 33222222222211111111110000000000
11493                                                  10987654321098765432109876543210
11494                                                  x10001x1x11xxxxx101xxxxxxxxxxxxx
11495                                                  ldff1sw.  */
11496                                               return 1685;
11497                                             }
11498                                         }
11499                                     }
11500                                 }
11501                               else
11502                                 {
11503                                   if (((word >> 15) & 0x1) == 0)
11504                                     {
11505                                       if (((word >> 21) & 0x1) == 0)
11506                                         {
11507                                           if (((word >> 31) & 0x1) == 0)
11508                                             {
11509                                               if (((word >> 10) & 0x1) == 0)
11510                                                 {
11511                                                   if (((word >> 11) & 0x1) == 0)
11512                                                     {
11513                                                       if (((word >> 12) & 0x1) == 0)
11514                                                         {
11515                                                           /* 33222222222211111111110000000000
11516                                                              10987654321098765432109876543210
11517                                                              010001x1xx0xxxxx011000xxxxxxxxxx
11518                                                              sqdmullb.  */
11519                                                           return 2183;
11520                                                         }
11521                                                       else
11522                                                         {
11523                                                           /* 33222222222211111111110000000000
11524                                                              10987654321098765432109876543210
11525                                                              010001x1xx0xxxxx011100xxxxxxxxxx
11526                                                              smullb.  */
11527                                                           return 2155;
11528                                                         }
11529                                                     }
11530                                                   else
11531                                                     {
11532                                                       if (((word >> 12) & 0x1) == 0)
11533                                                         {
11534                                                           if (((word >> 22) & 0x1) == 0)
11535                                                             {
11536                                                               /* 33222222222211111111110000000000
11537                                                                  10987654321098765432109876543210
11538                                                                  010001x1x00xxxxx011010xxxxxxxxxx
11539                                                                  pmullb.  */
11540                                                               return 2330;
11541                                                             }
11542                                                           else
11543                                                             {
11544                                                               /* 33222222222211111111110000000000
11545                                                                  10987654321098765432109876543210
11546                                                                  010001x1x10xxxxx011010xxxxxxxxxx
11547                                                                  pmullb.  */
11548                                                               return 2111;
11549                                                             }
11550                                                         }
11551                                                       else
11552                                                         {
11553                                                           /* 33222222222211111111110000000000
11554                                                              10987654321098765432109876543210
11555                                                              010001x1xx0xxxxx011110xxxxxxxxxx
11556                                                              umullb.  */
11557                                                           return 2280;
11558                                                         }
11559                                                     }
11560                                                 }
11561                                               else
11562                                                 {
11563                                                   if (((word >> 11) & 0x1) == 0)
11564                                                     {
11565                                                       if (((word >> 12) & 0x1) == 0)
11566                                                         {
11567                                                           /* 33222222222211111111110000000000
11568                                                              10987654321098765432109876543210
11569                                                              010001x1xx0xxxxx011001xxxxxxxxxx
11570                                                              sqdmullt.  */
11571                                                           return 2186;
11572                                                         }
11573                                                       else
11574                                                         {
11575                                                           /* 33222222222211111111110000000000
11576                                                              10987654321098765432109876543210
11577                                                              010001x1xx0xxxxx011101xxxxxxxxxx
11578                                                              smullt.  */
11579                                                           return 2158;
11580                                                         }
11581                                                     }
11582                                                   else
11583                                                     {
11584                                                       if (((word >> 12) & 0x1) == 0)
11585                                                         {
11586                                                           if (((word >> 22) & 0x1) == 0)
11587                                                             {
11588                                                               /* 33222222222211111111110000000000
11589                                                                  10987654321098765432109876543210
11590                                                                  010001x1x00xxxxx011011xxxxxxxxxx
11591                                                                  pmullt.  */
11592                                                               return 2331;
11593                                                             }
11594                                                           else
11595                                                             {
11596                                                               /* 33222222222211111111110000000000
11597                                                                  10987654321098765432109876543210
11598                                                                  010001x1x10xxxxx011011xxxxxxxxxx
11599                                                                  pmullt.  */
11600                                                               return 2112;
11601                                                             }
11602                                                         }
11603                                                       else
11604                                                         {
11605                                                           /* 33222222222211111111110000000000
11606                                                              10987654321098765432109876543210
11607                                                              010001x1xx0xxxxx011111xxxxxxxxxx
11608                                                              umullt.  */
11609                                                           return 2283;
11610                                                         }
11611                                                     }
11612                                                 }
11613                                             }
11614                                           else
11615                                             {
11616                                               if (((word >> 23) & 0x1) == 0)
11617                                                 {
11618                                                   /* 33222222222211111111110000000000
11619                                                      10987654321098765432109876543210
11620                                                      110001x10x0xxxxx011xxxxxxxxxxxxx
11621                                                      ldff1w.  */
11622                                                   return 1693;
11623                                                 }
11624                                               else
11625                                                 {
11626                                                   /* 33222222222211111111110000000000
11627                                                      10987654321098765432109876543210
11628                                                      110001x11x0xxxxx011xxxxxxxxxxxxx
11629                                                      ldff1d.  */
11630                                                   return 1638;
11631                                                 }
11632                                             }
11633                                         }
11634                                       else
11635                                         {
11636                                           if (((word >> 31) & 0x1) == 0)
11637                                             {
11638                                               if (((word >> 10) & 0x1) == 0)
11639                                                 {
11640                                                   if (((word >> 11) & 0x1) == 0)
11641                                                     {
11642                                                       if (((word >> 12) & 0x1) == 0)
11643                                                         {
11644                                                           /* 33222222222211111111110000000000
11645                                                              10987654321098765432109876543210
11646                                                              010001x1xx1xxxxx011000xxxxxxxxxx
11647                                                              addhnb.  */
11648                                                           return 2047;
11649                                                         }
11650                                                       else
11651                                                         {
11652                                                           /* 33222222222211111111110000000000
11653                                                              10987654321098765432109876543210
11654                                                              010001x1xx1xxxxx011100xxxxxxxxxx
11655                                                              subhnb.  */
11656                                                           return 2245;
11657                                                         }
11658                                                     }
11659                                                   else
11660                                                     {
11661                                                       if (((word >> 12) & 0x1) == 0)
11662                                                         {
11663                                                           /* 33222222222211111111110000000000
11664                                                              10987654321098765432109876543210
11665                                                              010001x1xx1xxxxx011010xxxxxxxxxx
11666                                                              raddhnb.  */
11667                                                           return 2113;
11668                                                         }
11669                                                       else
11670                                                         {
11671                                                           /* 33222222222211111111110000000000
11672                                                              10987654321098765432109876543210
11673                                                              010001x1xx1xxxxx011110xxxxxxxxxx
11674                                                              rsubhnb.  */
11675                                                           return 2117;
11676                                                         }
11677                                                     }
11678                                                 }
11679                                               else
11680                                                 {
11681                                                   if (((word >> 11) & 0x1) == 0)
11682                                                     {
11683                                                       if (((word >> 12) & 0x1) == 0)
11684                                                         {
11685                                                           /* 33222222222211111111110000000000
11686                                                              10987654321098765432109876543210
11687                                                              010001x1xx1xxxxx011001xxxxxxxxxx
11688                                                              addhnt.  */
11689                                                           return 2048;
11690                                                         }
11691                                                       else
11692                                                         {
11693                                                           /* 33222222222211111111110000000000
11694                                                              10987654321098765432109876543210
11695                                                              010001x1xx1xxxxx011101xxxxxxxxxx
11696                                                              subhnt.  */
11697                                                           return 2246;
11698                                                         }
11699                                                     }
11700                                                   else
11701                                                     {
11702                                                       if (((word >> 12) & 0x1) == 0)
11703                                                         {
11704                                                           /* 33222222222211111111110000000000
11705                                                              10987654321098765432109876543210
11706                                                              010001x1xx1xxxxx011011xxxxxxxxxx
11707                                                              raddhnt.  */
11708                                                           return 2114;
11709                                                         }
11710                                                       else
11711                                                         {
11712                                                           /* 33222222222211111111110000000000
11713                                                              10987654321098765432109876543210
11714                                                              010001x1xx1xxxxx011111xxxxxxxxxx
11715                                                              rsubhnt.  */
11716                                                           return 2118;
11717                                                         }
11718                                                     }
11719                                                 }
11720                                             }
11721                                           else
11722                                             {
11723                                               if (((word >> 23) & 0x1) == 0)
11724                                                 {
11725                                                   /* 33222222222211111111110000000000
11726                                                      10987654321098765432109876543210
11727                                                      110001x10x1xxxxx011xxxxxxxxxxxxx
11728                                                      ldff1w.  */
11729                                                   return 1694;
11730                                                 }
11731                                               else
11732                                                 {
11733                                                   /* 33222222222211111111110000000000
11734                                                      10987654321098765432109876543210
11735                                                      110001x11x1xxxxx011xxxxxxxxxxxxx
11736                                                      ldff1d.  */
11737                                                   return 1639;
11738                                                 }
11739                                             }
11740                                         }
11741                                     }
11742                                   else
11743                                     {
11744                                       if (((word >> 21) & 0x1) == 0)
11745                                         {
11746                                           if (((word >> 31) & 0x1) == 0)
11747                                             {
11748                                               if (((word >> 10) & 0x1) == 0)
11749                                                 {
11750                                                   if (((word >> 11) & 0x1) == 0)
11751                                                     {
11752                                                       if (((word >> 12) & 0x1) == 0)
11753                                                         {
11754                                                           /* 33222222222211111111110000000000
11755                                                              10987654321098765432109876543210
11756                                                              010001x1xx0xxxxx111000xxxxxxxxxx
11757                                                              ssra.  */
11758                                                           return 2231;
11759                                                         }
11760                                                       else
11761                                                         {
11762                                                           /* 33222222222211111111110000000000
11763                                                              10987654321098765432109876543210
11764                                                              010001x1xx0xxxxx111100xxxxxxxxxx
11765                                                              sri.  */
11766                                                           return 2224;
11767                                                         }
11768                                                     }
11769                                                   else
11770                                                     {
11771                                                       if (((word >> 12) & 0x1) == 0)
11772                                                         {
11773                                                           /* 33222222222211111111110000000000
11774                                                              10987654321098765432109876543210
11775                                                              010001x1xx0xxxxx111010xxxxxxxxxx
11776                                                              srsra.  */
11777                                                           return 2228;
11778                                                         }
11779                                                       else
11780                                                         {
11781                                                           /* 33222222222211111111110000000000
11782                                                              10987654321098765432109876543210
11783                                                              010001x1xx0xxxxx111110xxxxxxxxxx
11784                                                              saba.  */
11785                                                           return 2119;
11786                                                         }
11787                                                     }
11788                                                 }
11789                                               else
11790                                                 {
11791                                                   if (((word >> 11) & 0x1) == 0)
11792                                                     {
11793                                                       if (((word >> 12) & 0x1) == 0)
11794                                                         {
11795                                                           /* 33222222222211111111110000000000
11796                                                              10987654321098765432109876543210
11797                                                              010001x1xx0xxxxx111001xxxxxxxxxx
11798                                                              usra.  */
11799                                                           return 2308;
11800                                                         }
11801                                                       else
11802                                                         {
11803                                                           /* 33222222222211111111110000000000
11804                                                              10987654321098765432109876543210
11805                                                              010001x1xx0xxxxx111101xxxxxxxxxx
11806                                                              sli.  */
11807                                                           return 2137;
11808                                                         }
11809                                                     }
11810                                                   else
11811                                                     {
11812                                                       if (((word >> 12) & 0x1) == 0)
11813                                                         {
11814                                                           /* 33222222222211111111110000000000
11815                                                              10987654321098765432109876543210
11816                                                              010001x1xx0xxxxx111011xxxxxxxxxx
11817                                                              ursra.  */
11818                                                           return 2304;
11819                                                         }
11820                                                       else
11821                                                         {
11822                                                           /* 33222222222211111111110000000000
11823                                                              10987654321098765432109876543210
11824                                                              010001x1xx0xxxxx111111xxxxxxxxxx
11825                                                              uaba.  */
11826                                                           return 2250;
11827                                                         }
11828                                                     }
11829                                                 }
11830                                             }
11831                                           else
11832                                             {
11833                                               if (((word >> 22) & 0x1) == 0)
11834                                                 {
11835                                                   if (((word >> 23) & 0x1) == 0)
11836                                                     {
11837                                                       /* 33222222222211111111110000000000
11838                                                          10987654321098765432109876543210
11839                                                          110001x1000xxxxx111xxxxxxxxxxxxx
11840                                                          prfw.  */
11841                                                       return 1789;
11842                                                     }
11843                                                   else
11844                                                     {
11845                                                       /* 33222222222211111111110000000000
11846                                                          10987654321098765432109876543210
11847                                                          110001x1100xxxxx111xxxxxxxxxxxxx
11848                                                          prfd.  */
11849                                                       return 1775;
11850                                                     }
11851                                                 }
11852                                               else
11853                                                 {
11854                                                   if (((word >> 23) & 0x1) == 0)
11855                                                     {
11856                                                       /* 33222222222211111111110000000000
11857                                                          10987654321098765432109876543210
11858                                                          110001x1010xxxxx111xxxxxxxxxxxxx
11859                                                          ldff1w.  */
11860                                                       return 1695;
11861                                                     }
11862                                                   else
11863                                                     {
11864                                                       /* 33222222222211111111110000000000
11865                                                          10987654321098765432109876543210
11866                                                          110001x1110xxxxx111xxxxxxxxxxxxx
11867                                                          ldff1d.  */
11868                                                       return 1640;
11869                                                     }
11870                                                 }
11871                                             }
11872                                         }
11873                                       else
11874                                         {
11875                                           if (((word >> 22) & 0x1) == 0)
11876                                             {
11877                                               if (((word >> 23) & 0x1) == 0)
11878                                                 {
11879                                                   if (((word >> 31) & 0x1) == 0)
11880                                                     {
11881                                                       if (((word >> 10) & 0x1) == 0)
11882                                                         {
11883                                                           if (((word >> 12) & 0x1) == 0)
11884                                                             {
11885                                                               if (((word >> 16) & 0x1) == 0)
11886                                                                 {
11887                                                                   if (((word >> 17) & 0x1) == 0)
11888                                                                     {
11889                                                                       /* 33222222222211111111110000000000
11890                                                                          10987654321098765432109876543210
11891                                                                          010001x1001xxx001110x0xxxxxxxxxx
11892                                                                          aesmc.  */
11893                                                                       return 2329;
11894                                                                     }
11895                                                                   else
11896                                                                     {
11897                                                                       /* 33222222222211111111110000000000
11898                                                                          10987654321098765432109876543210
11899                                                                          010001x1001xxx101110x0xxxxxxxxxx
11900                                                                          aese.  */
11901                                                                       return 2327;
11902                                                                     }
11903                                                                 }
11904                                                               else
11905                                                                 {
11906                                                                   /* 33222222222211111111110000000000
11907                                                                      10987654321098765432109876543210
11908                                                                      010001x1001xxxx11110x0xxxxxxxxxx
11909                                                                      sm4e.  */
11910                                                                   return 2324;
11911                                                                 }
11912                                                             }
11913                                                           else
11914                                                             {
11915                                                               /* 33222222222211111111110000000000
11916                                                                  10987654321098765432109876543210
11917                                                                  010001x1001xxxxx1111x0xxxxxxxxxx
11918                                                                  sm4ekey.  */
11919                                                               return 2325;
11920                                                             }
11921                                                         }
11922                                                       else
11923                                                         {
11924                                                           if (((word >> 12) & 0x1) == 0)
11925                                                             {
11926                                                               if (((word >> 17) & 0x1) == 0)
11927                                                                 {
11928                                                                   /* 33222222222211111111110000000000
11929                                                                      10987654321098765432109876543210
11930                                                                      010001x1001xxx0x1110x1xxxxxxxxxx
11931                                                                      aesimc.  */
11932                                                                   return 2328;
11933                                                                 }
11934                                                               else
11935                                                                 {
11936                                                                   /* 33222222222211111111110000000000
11937                                                                      10987654321098765432109876543210
11938                                                                      010001x1001xxx1x1110x1xxxxxxxxxx
11939                                                                      aesd.  */
11940                                                                   return 2326;
11941                                                                 }
11942                                                             }
11943                                                           else
11944                                                             {
11945                                                               /* 33222222222211111111110000000000
11946                                                                  10987654321098765432109876543210
11947                                                                  010001x1001xxxxx1111x1xxxxxxxxxx
11948                                                                  rax1.  */
11949                                                               return 2332;
11950                                                             }
11951                                                         }
11952                                                     }
11953                                                   else
11954                                                     {
11955                                                       /* 33222222222211111111110000000000
11956                                                          10987654321098765432109876543210
11957                                                          110001x1001xxxxx111xxxxxxxxxxxxx
11958                                                          ldff1w.  */
11959                                                       return 1698;
11960                                                     }
11961                                                 }
11962                                               else
11963                                                 {
11964                                                   /* 33222222222211111111110000000000
11965                                                      10987654321098765432109876543210
11966                                                      x10001x1101xxxxx111xxxxxxxxxxxxx
11967                                                      ldff1d.  */
11968                                                   return 1642;
11969                                                 }
11970                                             }
11971                                           else
11972                                             {
11973                                               if (((word >> 23) & 0x1) == 0)
11974                                                 {
11975                                                   /* 33222222222211111111110000000000
11976                                                      10987654321098765432109876543210
11977                                                      x10001x1011xxxxx111xxxxxxxxxxxxx
11978                                                      ldff1w.  */
11979                                                   return 1696;
11980                                                 }
11981                                               else
11982                                                 {
11983                                                   /* 33222222222211111111110000000000
11984                                                      10987654321098765432109876543210
11985                                                      x10001x1111xxxxx111xxxxxxxxxxxxx
11986                                                      ldff1d.  */
11987                                                   return 1641;
11988                                                 }
11989                                             }
11990                                         }
11991                                     }
11992                                 }
11993                             }
11994                         }
11995                     }
11996                   else
11997                     {
11998                       if (((word >> 15) & 0x1) == 0)
11999                         {
12000                           if (((word >> 14) & 0x1) == 0)
12001                             {
12002                               if (((word >> 13) & 0x1) == 0)
12003                                 {
12004                                   if (((word >> 30) & 0x1) == 0)
12005                                     {
12006                                       if (((word >> 21) & 0x1) == 0)
12007                                         {
12008                                           if (((word >> 31) & 0x1) == 0)
12009                                             {
12010                                               if (((word >> 4) & 0x1) == 0)
12011                                                 {
12012                                                   /* 33222222222211111111110000000000
12013                                                      10987654321098765432109876543210
12014                                                      001001x1xx0xxxxx000xxxxxxxx0xxxx
12015                                                      cmpge.  */
12016                                                   return 1321;
12017                                                 }
12018                                               else
12019                                                 {
12020                                                   /* 33222222222211111111110000000000
12021                                                      10987654321098765432109876543210
12022                                                      001001x1xx0xxxxx000xxxxxxxx1xxxx
12023                                                      cmpgt.  */
12024                                                   return 1324;
12025                                                 }
12026                                             }
12027                                           else
12028                                             {
12029                                               if (((word >> 23) & 0x1) == 0)
12030                                                 {
12031                                                   /* 33222222222211111111110000000000
12032                                                      10987654321098765432109876543210
12033                                                      101001x10x0xxxxx000xxxxxxxxxxxxx
12034                                                      ld1rqw.  */
12035                                                   return 1548;
12036                                                 }
12037                                               else
12038                                                 {
12039                                                   /* 33222222222211111111110000000000
12040                                                      10987654321098765432109876543210
12041                                                      101001x11x0xxxxx000xxxxxxxxxxxxx
12042                                                      ld1rqd.  */
12043                                                   return 1544;
12044                                                 }
12045                                             }
12046                                         }
12047                                       else
12048                                         {
12049                                           if (((word >> 4) & 0x1) == 0)
12050                                             {
12051                                               if (((word >> 10) & 0x1) == 0)
12052                                                 {
12053                                                   if (((word >> 11) & 0x1) == 0)
12054                                                     {
12055                                                       if (((word >> 12) & 0x1) == 0)
12056                                                         {
12057                                                           /* 33222222222211111111110000000000
12058                                                              10987654321098765432109876543210
12059                                                              x01001x1xx1xxxxx000000xxxxx0xxxx
12060                                                              whilege.  */
12061                                                           return 2313;
12062                                                         }
12063                                                       else
12064                                                         {
12065                                                           /* 33222222222211111111110000000000
12066                                                              10987654321098765432109876543210
12067                                                              x01001x1xx1xxxxx000100xxxxx0xxxx
12068                                                              whilege.  */
12069                                                           return 2314;
12070                                                         }
12071                                                     }
12072                                                   else
12073                                                     {
12074                                                       if (((word >> 12) & 0x1) == 0)
12075                                                         {
12076                                                           /* 33222222222211111111110000000000
12077                                                              10987654321098765432109876543210
12078                                                              x01001x1xx1xxxxx000010xxxxx0xxxx
12079                                                              whilehs.  */
12080                                                           return 2319;
12081                                                         }
12082                                                       else
12083                                                         {
12084                                                           /* 33222222222211111111110000000000
12085                                                              10987654321098765432109876543210
12086                                                              x01001x1xx1xxxxx000110xxxxx0xxxx
12087                                                              whilehs.  */
12088                                                           return 2320;
12089                                                         }
12090                                                     }
12091                                                 }
12092                                               else
12093                                                 {
12094                                                   if (((word >> 11) & 0x1) == 0)
12095                                                     {
12096                                                       if (((word >> 12) & 0x1) == 0)
12097                                                         {
12098                                                           /* 33222222222211111111110000000000
12099                                                              10987654321098765432109876543210
12100                                                              x01001x1xx1xxxxx000001xxxxx0xxxx
12101                                                              whilelt.  */
12102                                                           return 2025;
12103                                                         }
12104                                                       else
12105                                                         {
12106                                                           /* 33222222222211111111110000000000
12107                                                              10987654321098765432109876543210
12108                                                              x01001x1xx1xxxxx000101xxxxx0xxxx
12109                                                              whilelt.  */
12110                                                           return 2026;
12111                                                         }
12112                                                     }
12113                                                   else
12114                                                     {
12115                                                       if (((word >> 12) & 0x1) == 0)
12116                                                         {
12117                                                           /* 33222222222211111111110000000000
12118                                                              10987654321098765432109876543210
12119                                                              x01001x1xx1xxxxx000011xxxxx0xxxx
12120                                                              whilelo.  */
12121                                                           return 2021;
12122                                                         }
12123                                                       else
12124                                                         {
12125                                                           /* 33222222222211111111110000000000
12126                                                              10987654321098765432109876543210
12127                                                              x01001x1xx1xxxxx000111xxxxx0xxxx
12128                                                              whilelo.  */
12129                                                           return 2022;
12130                                                         }
12131                                                     }
12132                                                 }
12133                                             }
12134                                           else
12135                                             {
12136                                               if (((word >> 10) & 0x1) == 0)
12137                                                 {
12138                                                   if (((word >> 11) & 0x1) == 0)
12139                                                     {
12140                                                       if (((word >> 12) & 0x1) == 0)
12141                                                         {
12142                                                           /* 33222222222211111111110000000000
12143                                                              10987654321098765432109876543210
12144                                                              x01001x1xx1xxxxx000000xxxxx1xxxx
12145                                                              whilegt.  */
12146                                                           return 2315;
12147                                                         }
12148                                                       else
12149                                                         {
12150                                                           /* 33222222222211111111110000000000
12151                                                              10987654321098765432109876543210
12152                                                              x01001x1xx1xxxxx000100xxxxx1xxxx
12153                                                              whilegt.  */
12154                                                           return 2316;
12155                                                         }
12156                                                     }
12157                                                   else
12158                                                     {
12159                                                       if (((word >> 12) & 0x1) == 0)
12160                                                         {
12161                                                           /* 33222222222211111111110000000000
12162                                                              10987654321098765432109876543210
12163                                                              x01001x1xx1xxxxx000010xxxxx1xxxx
12164                                                              whilehi.  */
12165                                                           return 2317;
12166                                                         }
12167                                                       else
12168                                                         {
12169                                                           /* 33222222222211111111110000000000
12170                                                              10987654321098765432109876543210
12171                                                              x01001x1xx1xxxxx000110xxxxx1xxxx
12172                                                              whilehi.  */
12173                                                           return 2318;
12174                                                         }
12175                                                     }
12176                                                 }
12177                                               else
12178                                                 {
12179                                                   if (((word >> 11) & 0x1) == 0)
12180                                                     {
12181                                                       if (((word >> 12) & 0x1) == 0)
12182                                                         {
12183                                                           /* 33222222222211111111110000000000
12184                                                              10987654321098765432109876543210
12185                                                              x01001x1xx1xxxxx000001xxxxx1xxxx
12186                                                              whilele.  */
12187                                                           return 2019;
12188                                                         }
12189                                                       else
12190                                                         {
12191                                                           /* 33222222222211111111110000000000
12192                                                              10987654321098765432109876543210
12193                                                              x01001x1xx1xxxxx000101xxxxx1xxxx
12194                                                              whilele.  */
12195                                                           return 2020;
12196                                                         }
12197                                                     }
12198                                                   else
12199                                                     {
12200                                                       if (((word >> 12) & 0x1) == 0)
12201                                                         {
12202                                                           /* 33222222222211111111110000000000
12203                                                              10987654321098765432109876543210
12204                                                              x01001x1xx1xxxxx000011xxxxx1xxxx
12205                                                              whilels.  */
12206                                                           return 2023;
12207                                                         }
12208                                                       else
12209                                                         {
12210                                                           /* 33222222222211111111110000000000
12211                                                              10987654321098765432109876543210
12212                                                              x01001x1xx1xxxxx000111xxxxx1xxxx
12213                                                              whilels.  */
12214                                                           return 2024;
12215                                                         }
12216                                                     }
12217                                                 }
12218                                             }
12219                                         }
12220                                     }
12221                                   else
12222                                     {
12223                                       if (((word >> 31) & 0x1) == 0)
12224                                         {
12225                                           if (((word >> 21) & 0x1) == 0)
12226                                             {
12227                                               if (((word >> 10) & 0x1) == 0)
12228                                                 {
12229                                                   if (((word >> 11) & 0x1) == 0)
12230                                                     {
12231                                                       /* 33222222222211111111110000000000
12232                                                          10987654321098765432109876543210
12233                                                          011001x1xx0xxxxx000x00xxxxxxxxxx
12234                                                          fadd.  */
12235                                                       return 1379;
12236                                                     }
12237                                                   else
12238                                                     {
12239                                                       if (((word >> 12) & 0x1) == 0)
12240                                                         {
12241                                                           /* 33222222222211111111110000000000
12242                                                              10987654321098765432109876543210
12243                                                              011001x1xx0xxxxx000010xxxxxxxxxx
12244                                                              fmul.  */
12245                                                           return 1446;
12246                                                         }
12247                                                       else
12248                                                         {
12249                                                           /* 33222222222211111111110000000000
12250                                                              10987654321098765432109876543210
12251                                                              011001x1xx0xxxxx000110xxxxxxxxxx
12252                                                              frecps.  */
12253                                                           return 1459;
12254                                                         }
12255                                                     }
12256                                                 }
12257                                               else
12258                                                 {
12259                                                   if (((word >> 11) & 0x1) == 0)
12260                                                     {
12261                                                       /* 33222222222211111111110000000000
12262                                                          10987654321098765432109876543210
12263                                                          011001x1xx0xxxxx000x01xxxxxxxxxx
12264                                                          fsub.  */
12265                                                       return 1472;
12266                                                     }
12267                                                   else
12268                                                     {
12269                                                       if (((word >> 12) & 0x1) == 0)
12270                                                         {
12271                                                           /* 33222222222211111111110000000000
12272                                                              10987654321098765432109876543210
12273                                                              011001x1xx0xxxxx000011xxxxxxxxxx
12274                                                              ftsmul.  */
12275                                                           return 1478;
12276                                                         }
12277                                                       else
12278                                                         {
12279                                                           /* 33222222222211111111110000000000
12280                                                              10987654321098765432109876543210
12281                                                              011001x1xx0xxxxx000111xxxxxxxxxx
12282                                                              frsqrts.  */
12283                                                           return 1469;
12284                                                         }
12285                                                     }
12286                                                 }
12287                                             }
12288                                           else
12289                                             {
12290                                               /* 33222222222211111111110000000000
12291                                                  10987654321098765432109876543210
12292                                                  011001x1xx1xxxxx000xxxxxxxxxxxxx
12293                                                  fmla.  */
12294                                               return 1437;
12295                                             }
12296                                         }
12297                                       else
12298                                         {
12299                                           /* 33222222222211111111110000000000
12300                                              10987654321098765432109876543210
12301                                              111001x1xxxxxxxx000xxxxxxxxxxxxx
12302                                              str.  */
12303                                           return 1940;
12304                                         }
12305                                     }
12306                                 }
12307                               else
12308                                 {
12309                                   if (((word >> 21) & 0x1) == 0)
12310                                     {
12311                                       if (((word >> 30) & 0x1) == 0)
12312                                         {
12313                                           if (((word >> 31) & 0x1) == 0)
12314                                             {
12315                                               if (((word >> 4) & 0x1) == 0)
12316                                                 {
12317                                                   /* 33222222222211111111110000000000
12318                                                      10987654321098765432109876543210
12319                                                      001001x1xx0xxxxx001xxxxxxxx0xxxx
12320                                                      cmplt.  */
12321                                                   return 1338;
12322                                                 }
12323                                               else
12324                                                 {
12325                                                   /* 33222222222211111111110000000000
12326                                                      10987654321098765432109876543210
12327                                                      001001x1xx0xxxxx001xxxxxxxx1xxxx
12328                                                      cmple.  */
12329                                                   return 1332;
12330                                                 }
12331                                             }
12332                                           else
12333                                             {
12334                                               if (((word >> 23) & 0x1) == 0)
12335                                                 {
12336                                                   /* 33222222222211111111110000000000
12337                                                      10987654321098765432109876543210
12338                                                      101001x10x0xxxxx001xxxxxxxxxxxxx
12339                                                      ld1rqw.  */
12340                                                   return 1547;
12341                                                 }
12342                                               else
12343                                                 {
12344                                                   /* 33222222222211111111110000000000
12345                                                      10987654321098765432109876543210
12346                                                      101001x11x0xxxxx001xxxxxxxxxxxxx
12347                                                      ld1rqd.  */
12348                                                   return 1543;
12349                                                 }
12350                                             }
12351                                         }
12352                                       else
12353                                         {
12354                                           if (((word >> 31) & 0x1) == 0)
12355                                             {
12356                                               if (((word >> 16) & 0x1) == 0)
12357                                                 {
12358                                                   if (((word >> 17) & 0x1) == 0)
12359                                                     {
12360                                                       if (((word >> 18) & 0x1) == 0)
12361                                                         {
12362                                                           if (((word >> 19) & 0x1) == 0)
12363                                                             {
12364                                                               if (((word >> 20) & 0x1) == 0)
12365                                                                 {
12366                                                                   /* 33222222222211111111110000000000
12367                                                                      10987654321098765432109876543210
12368                                                                      011001x1xx000000001xxxxxxxxxxxxx
12369                                                                      faddv.  */
12370                                                                   return 1383;
12371                                                                 }
12372                                                               else
12373                                                                 {
12374                                                                   if (((word >> 4) & 0x1) == 0)
12375                                                                     {
12376                                                                       /* 33222222222211111111110000000000
12377                                                                          10987654321098765432109876543210
12378                                                                          011001x1xx010000001xxxxxxxx0xxxx
12379                                                                          fcmge.  */
12380                                                                       return 1390;
12381                                                                     }
12382                                                                   else
12383                                                                     {
12384                                                                       /* 33222222222211111111110000000000
12385                                                                          10987654321098765432109876543210
12386                                                                          011001x1xx010000001xxxxxxxx1xxxx
12387                                                                          fcmgt.  */
12388                                                                       return 1392;
12389                                                                     }
12390                                                                 }
12391                                                             }
12392                                                           else
12393                                                             {
12394                                                               /* 33222222222211111111110000000000
12395                                                                  10987654321098765432109876543210
12396                                                                  011001x1xx0x1000001xxxxxxxxxxxxx
12397                                                                  fadda.  */
12398                                                               return 1382;
12399                                                             }
12400                                                         }
12401                                                       else
12402                                                         {
12403                                                           /* 33222222222211111111110000000000
12404                                                              10987654321098765432109876543210
12405                                                              011001x1xx0xx100001xxxxxxxxxxxxx
12406                                                              fmaxnmv.  */
12407                                                           return 1429;
12408                                                         }
12409                                                     }
12410                                                   else
12411                                                     {
12412                                                       if (((word >> 18) & 0x1) == 0)
12413                                                         {
12414                                                           /* 33222222222211111111110000000000
12415                                                              10987654321098765432109876543210
12416                                                              011001x1xx0xx010001xxxxxxxxxxxxx
12417                                                              fcmeq.  */
12418                                                           return 1388;
12419                                                         }
12420                                                       else
12421                                                         {
12422                                                           if (((word >> 19) & 0x1) == 0)
12423                                                             {
12424                                                               /* 33222222222211111111110000000000
12425                                                                  10987654321098765432109876543210
12426                                                                  011001x1xx0x0110001xxxxxxxxxxxxx
12427                                                                  fmaxv.  */
12428                                                               return 1430;
12429                                                             }
12430                                                           else
12431                                                             {
12432                                                               /* 33222222222211111111110000000000
12433                                                                  10987654321098765432109876543210
12434                                                                  011001x1xx0x1110001xxxxxxxxxxxxx
12435                                                                  frecpe.  */
12436                                                               return 1458;
12437                                                             }
12438                                                         }
12439                                                     }
12440                                                 }
12441                                               else
12442                                                 {
12443                                                   if (((word >> 17) & 0x1) == 0)
12444                                                     {
12445                                                       if (((word >> 18) & 0x1) == 0)
12446                                                         {
12447                                                           if (((word >> 4) & 0x1) == 0)
12448                                                             {
12449                                                               /* 33222222222211111111110000000000
12450                                                                  10987654321098765432109876543210
12451                                                                  011001x1xx0xx001001xxxxxxxx0xxxx
12452                                                                  fcmlt.  */
12453                                                               return 1395;
12454                                                             }
12455                                                           else
12456                                                             {
12457                                                               /* 33222222222211111111110000000000
12458                                                                  10987654321098765432109876543210
12459                                                                  011001x1xx0xx001001xxxxxxxx1xxxx
12460                                                                  fcmle.  */
12461                                                               return 1394;
12462                                                             }
12463                                                         }
12464                                                       else
12465                                                         {
12466                                                           /* 33222222222211111111110000000000
12467                                                              10987654321098765432109876543210
12468                                                              011001x1xx0xx101001xxxxxxxxxxxxx
12469                                                              fminnmv.  */
12470                                                           return 1435;
12471                                                         }
12472                                                     }
12473                                                   else
12474                                                     {
12475                                                       if (((word >> 18) & 0x1) == 0)
12476                                                         {
12477                                                           /* 33222222222211111111110000000000
12478                                                              10987654321098765432109876543210
12479                                                              011001x1xx0xx011001xxxxxxxxxxxxx
12480                                                              fcmne.  */
12481                                                           return 1396;
12482                                                         }
12483                                                       else
12484                                                         {
12485                                                           if (((word >> 19) & 0x1) == 0)
12486                                                             {
12487                                                               /* 33222222222211111111110000000000
12488                                                                  10987654321098765432109876543210
12489                                                                  011001x1xx0x0111001xxxxxxxxxxxxx
12490                                                                  fminv.  */
12491                                                               return 1436;
12492                                                             }
12493                                                           else
12494                                                             {
12495                                                               /* 33222222222211111111110000000000
12496                                                                  10987654321098765432109876543210
12497                                                                  011001x1xx0x1111001xxxxxxxxxxxxx
12498                                                                  frsqrte.  */
12499                                                               return 1468;
12500                                                             }
12501                                                         }
12502                                                     }
12503                                                 }
12504                                             }
12505                                           else
12506                                             {
12507                                               if (((word >> 22) & 0x1) == 0)
12508                                                 {
12509                                                   if (((word >> 23) & 0x1) == 0)
12510                                                     {
12511                                                       /* 33222222222211111111110000000000
12512                                                          10987654321098765432109876543210
12513                                                          111001x1000xxxxx001xxxxxxxxxxxxx
12514                                                          stnt1w.  */
12515                                                       return 2244;
12516                                                     }
12517                                                   else
12518                                                     {
12519                                                       /* 33222222222211111111110000000000
12520                                                          10987654321098765432109876543210
12521                                                          111001x1100xxxxx001xxxxxxxxxxxxx
12522                                                          stnt1d.  */
12523                                                       return 2240;
12524                                                     }
12525                                                 }
12526                                               else
12527                                                 {
12528                                                   /* 33222222222211111111110000000000
12529                                                      10987654321098765432109876543210
12530                                                      111001x1x10xxxxx001xxxxxxxxxxxxx
12531                                                      stnt1w.  */
12532                                                   return 2243;
12533                                                 }
12534                                             }
12535                                         }
12536                                     }
12537                                   else
12538                                     {
12539                                       if (((word >> 30) & 0x1) == 0)
12540                                         {
12541                                           if (((word >> 4) & 0x1) == 0)
12542                                             {
12543                                               if (((word >> 12) & 0x1) == 0)
12544                                                 {
12545                                                   /* 33222222222211111111110000000000
12546                                                      10987654321098765432109876543210
12547                                                      x01001x1xx1xxxxx0010xxxxxxx0xxxx
12548                                                      ctermeq.  */
12549                                                   return 1353;
12550                                                 }
12551                                               else
12552                                                 {
12553                                                   /* 33222222222211111111110000000000
12554                                                      10987654321098765432109876543210
12555                                                      x01001x1xx1xxxxx0011xxxxxxx0xxxx
12556                                                      whilewr.  */
12557                                                   return 2322;
12558                                                 }
12559                                             }
12560                                           else
12561                                             {
12562                                               if (((word >> 12) & 0x1) == 0)
12563                                                 {
12564                                                   /* 33222222222211111111110000000000
12565                                                      10987654321098765432109876543210
12566                                                      x01001x1xx1xxxxx0010xxxxxxx1xxxx
12567                                                      ctermne.  */
12568                                                   return 1354;
12569                                                 }
12570                                               else
12571                                                 {
12572                                                   /* 33222222222211111111110000000000
12573                                                      10987654321098765432109876543210
12574                                                      x01001x1xx1xxxxx0011xxxxxxx1xxxx
12575                                                      whilerw.  */
12576                                                   return 2321;
12577                                                 }
12578                                             }
12579                                         }
12580                                       else
12581                                         {
12582                                           /* 33222222222211111111110000000000
12583                                              10987654321098765432109876543210
12584                                              x11001x1xx1xxxxx001xxxxxxxxxxxxx
12585                                              fmls.  */
12586                                           return 1441;
12587                                         }
12588                                     }
12589                                 }
12590                             }
12591                           else
12592                             {
12593                               if (((word >> 30) & 0x1) == 0)
12594                                 {
12595                                   if (((word >> 21) & 0x1) == 0)
12596                                     {
12597                                       if (((word >> 22) & 0x1) == 0)
12598                                         {
12599                                           if (((word >> 23) & 0x1) == 0)
12600                                             {
12601                                               if (((word >> 31) & 0x1) == 0)
12602                                                 {
12603                                                   if (((word >> 9) & 0x1) == 0)
12604                                                     {
12605                                                       if (((word >> 20) & 0x1) == 0)
12606                                                         {
12607                                                           if (((word >> 4) & 0x1) == 0)
12608                                                             {
12609                                                               /* 33222222222211111111110000000000
12610                                                                  10987654321098765432109876543210
12611                                                                  001001x10000xxxx01xxxx0xxxx0xxxx
12612                                                                  and.  */
12613                                                               return 1284;
12614                                                             }
12615                                                           else
12616                                                             {
12617                                                               /* 33222222222211111111110000000000
12618                                                                  10987654321098765432109876543210
12619                                                                  001001x10000xxxx01xxxx0xxxx1xxxx
12620                                                                  bic.  */
12621                                                               return 1296;
12622                                                             }
12623                                                         }
12624                                                       else
12625                                                         {
12626                                                           if (((word >> 19) & 0x1) == 0)
12627                                                             {
12628                                                               /* 33222222222211111111110000000000
12629                                                                  10987654321098765432109876543210
12630                                                                  001001x100010xxx01xxxx0xxxxxxxxx
12631                                                                  brka.  */
12632                                                               return 1298;
12633                                                             }
12634                                                           else
12635                                                             {
12636                                                               /* 33222222222211111111110000000000
12637                                                                  10987654321098765432109876543210
12638                                                                  001001x100011xxx01xxxx0xxxxxxxxx
12639                                                                  brkn.  */
12640                                                               return 1302;
12641                                                             }
12642                                                         }
12643                                                     }
12644                                                   else
12645                                                     {
12646                                                       if (((word >> 4) & 0x1) == 0)
12647                                                         {
12648                                                           /* 33222222222211111111110000000000
12649                                                              10987654321098765432109876543210
12650                                                              001001x1000xxxxx01xxxx1xxxx0xxxx
12651                                                              eor.  */
12652                                                           return 1371;
12653                                                         }
12654                                                       else
12655                                                         {
12656                                                           /* 33222222222211111111110000000000
12657                                                              10987654321098765432109876543210
12658                                                              001001x1000xxxxx01xxxx1xxxx1xxxx
12659                                                              sel.  */
12660                                                           return 1820;
12661                                                         }
12662                                                     }
12663                                                 }
12664                                               else
12665                                                 {
12666                                                   if (((word >> 13) & 0x1) == 0)
12667                                                     {
12668                                                       /* 33222222222211111111110000000000
12669                                                          10987654321098765432109876543210
12670                                                          101001x1000xxxxx010xxxxxxxxxxxxx
12671                                                          ld1sh.  */
12672                                                       return 1570;
12673                                                     }
12674                                                   else
12675                                                     {
12676                                                       /* 33222222222211111111110000000000
12677                                                          10987654321098765432109876543210
12678                                                          101001x1000xxxxx011xxxxxxxxxxxxx
12679                                                          ldff1sh.  */
12680                                                       return 1670;
12681                                                     }
12682                                                 }
12683                                             }
12684                                           else
12685                                             {
12686                                               if (((word >> 31) & 0x1) == 0)
12687                                                 {
12688                                                   if (((word >> 9) & 0x1) == 0)
12689                                                     {
12690                                                       if (((word >> 20) & 0x1) == 0)
12691                                                         {
12692                                                           if (((word >> 4) & 0x1) == 0)
12693                                                             {
12694                                                               /* 33222222222211111111110000000000
12695                                                                  10987654321098765432109876543210
12696                                                                  001001x11000xxxx01xxxx0xxxx0xxxx
12697                                                                  orr.  */
12698                                                               return 1756;
12699                                                             }
12700                                                           else
12701                                                             {
12702                                                               /* 33222222222211111111110000000000
12703                                                                  10987654321098765432109876543210
12704                                                                  001001x11000xxxx01xxxx0xxxx1xxxx
12705                                                                  orn.  */
12706                                                               return 1751;
12707                                                             }
12708                                                         }
12709                                                       else
12710                                                         {
12711                                                           /* 33222222222211111111110000000000
12712                                                              10987654321098765432109876543210
12713                                                              001001x11001xxxx01xxxx0xxxxxxxxx
12714                                                              brkb.  */
12715                                                           return 1300;
12716                                                         }
12717                                                     }
12718                                                   else
12719                                                     {
12720                                                       if (((word >> 4) & 0x1) == 0)
12721                                                         {
12722                                                           /* 33222222222211111111110000000000
12723                                                              10987654321098765432109876543210
12724                                                              001001x1100xxxxx01xxxx1xxxx0xxxx
12725                                                              nor.  */
12726                                                           return 1748;
12727                                                         }
12728                                                       else
12729                                                         {
12730                                                           /* 33222222222211111111110000000000
12731                                                              10987654321098765432109876543210
12732                                                              001001x1100xxxxx01xxxx1xxxx1xxxx
12733                                                              nand.  */
12734                                                           return 1745;
12735                                                         }
12736                                                     }
12737                                                 }
12738                                               else
12739                                                 {
12740                                                   if (((word >> 13) & 0x1) == 0)
12741                                                     {
12742                                                       /* 33222222222211111111110000000000
12743                                                          10987654321098765432109876543210
12744                                                          101001x1100xxxxx010xxxxxxxxxxxxx
12745                                                          ld1sb.  */
12746                                                       return 1558;
12747                                                     }
12748                                                   else
12749                                                     {
12750                                                       /* 33222222222211111111110000000000
12751                                                          10987654321098765432109876543210
12752                                                          101001x1100xxxxx011xxxxxxxxxxxxx
12753                                                          ldff1sb.  */
12754                                                       return 1658;
12755                                                     }
12756                                                 }
12757                                             }
12758                                         }
12759                                       else
12760                                         {
12761                                           if (((word >> 23) & 0x1) == 0)
12762                                             {
12763                                               if (((word >> 31) & 0x1) == 0)
12764                                                 {
12765                                                   if (((word >> 4) & 0x1) == 0)
12766                                                     {
12767                                                       if (((word >> 9) & 0x1) == 0)
12768                                                         {
12769                                                           if (((word >> 20) & 0x1) == 0)
12770                                                             {
12771                                                               /* 33222222222211111111110000000000
12772                                                                  10987654321098765432109876543210
12773                                                                  001001x10100xxxx01xxxx0xxxx0xxxx
12774                                                                  ands.  */
12775                                                               return 1285;
12776                                                             }
12777                                                           else
12778                                                             {
12779                                                               if (((word >> 19) & 0x1) == 0)
12780                                                                 {
12781                                                                   /* 33222222222211111111110000000000
12782                                                                      10987654321098765432109876543210
12783                                                                      001001x101010xxx01xxxx0xxxx0xxxx
12784                                                                      brkas.  */
12785                                                                   return 1299;
12786                                                                 }
12787                                                               else
12788                                                                 {
12789                                                                   /* 33222222222211111111110000000000
12790                                                                      10987654321098765432109876543210
12791                                                                      001001x101011xxx01xxxx0xxxx0xxxx
12792                                                                      brkns.  */
12793                                                                   return 1303;
12794                                                                 }
12795                                                             }
12796                                                         }
12797                                                       else
12798                                                         {
12799                                                           /* 33222222222211111111110000000000
12800                                                              10987654321098765432109876543210
12801                                                              001001x1010xxxxx01xxxx1xxxx0xxxx
12802                                                              eors.  */
12803                                                           return 1372;
12804                                                         }
12805                                                     }
12806                                                   else
12807                                                     {
12808                                                       /* 33222222222211111111110000000000
12809                                                          10987654321098765432109876543210
12810                                                          001001x1010xxxxx01xxxxxxxxx1xxxx
12811                                                          bics.  */
12812                                                       return 1297;
12813                                                     }
12814                                                 }
12815                                               else
12816                                                 {
12817                                                   if (((word >> 13) & 0x1) == 0)
12818                                                     {
12819                                                       /* 33222222222211111111110000000000
12820                                                          10987654321098765432109876543210
12821                                                          101001x1010xxxxx010xxxxxxxxxxxxx
12822                                                          ld1w.  */
12823                                                       return 1589;
12824                                                     }
12825                                                   else
12826                                                     {
12827                                                       /* 33222222222211111111110000000000
12828                                                          10987654321098765432109876543210
12829                                                          101001x1010xxxxx011xxxxxxxxxxxxx
12830                                                          ldff1w.  */
12831                                                       return 1689;
12832                                                     }
12833                                                 }
12834                                             }
12835                                           else
12836                                             {
12837                                               if (((word >> 31) & 0x1) == 0)
12838                                                 {
12839                                                   if (((word >> 4) & 0x1) == 0)
12840                                                     {
12841                                                       if (((word >> 9) & 0x1) == 0)
12842                                                         {
12843                                                           if (((word >> 20) & 0x1) == 0)
12844                                                             {
12845                                                               /* 33222222222211111111110000000000
12846                                                                  10987654321098765432109876543210
12847                                                                  001001x11100xxxx01xxxx0xxxx0xxxx
12848                                                                  orrs.  */
12849                                                               return 1757;
12850                                                             }
12851                                                           else
12852                                                             {
12853                                                               /* 33222222222211111111110000000000
12854                                                                  10987654321098765432109876543210
12855                                                                  001001x11101xxxx01xxxx0xxxx0xxxx
12856                                                                  brkbs.  */
12857                                                               return 1301;
12858                                                             }
12859                                                         }
12860                                                       else
12861                                                         {
12862                                                           /* 33222222222211111111110000000000
12863                                                              10987654321098765432109876543210
12864                                                              001001x1110xxxxx01xxxx1xxxx0xxxx
12865                                                              nors.  */
12866                                                           return 1749;
12867                                                         }
12868                                                     }
12869                                                   else
12870                                                     {
12871                                                       if (((word >> 9) & 0x1) == 0)
12872                                                         {
12873                                                           /* 33222222222211111111110000000000
12874                                                              10987654321098765432109876543210
12875                                                              001001x1110xxxxx01xxxx0xxxx1xxxx
12876                                                              orns.  */
12877                                                           return 1752;
12878                                                         }
12879                                                       else
12880                                                         {
12881                                                           /* 33222222222211111111110000000000
12882                                                              10987654321098765432109876543210
12883                                                              001001x1110xxxxx01xxxx1xxxx1xxxx
12884                                                              nands.  */
12885                                                           return 1746;
12886                                                         }
12887                                                     }
12888                                                 }
12889                                               else
12890                                                 {
12891                                                   if (((word >> 13) & 0x1) == 0)
12892                                                     {
12893                                                       /* 33222222222211111111110000000000
12894                                                          10987654321098765432109876543210
12895                                                          101001x1110xxxxx010xxxxxxxxxxxxx
12896                                                          ld1sb.  */
12897                                                       return 1560;
12898                                                     }
12899                                                   else
12900                                                     {
12901                                                       /* 33222222222211111111110000000000
12902                                                          10987654321098765432109876543210
12903                                                          101001x1110xxxxx011xxxxxxxxxxxxx
12904                                                          ldff1sb.  */
12905                                                       return 1662;
12906                                                     }
12907                                                 }
12908                                             }
12909                                         }
12910                                     }
12911                                   else
12912                                     {
12913                                       if (((word >> 13) & 0x1) == 0)
12914                                         {
12915                                           if (((word >> 22) & 0x1) == 0)
12916                                             {
12917                                               if (((word >> 23) & 0x1) == 0)
12918                                                 {
12919                                                   /* 33222222222211111111110000000000
12920                                                      10987654321098765432109876543210
12921                                                      x01001x1001xxxxx010xxxxxxxxxxxxx
12922                                                      ld1sh.  */
12923                                                   return 1571;
12924                                                 }
12925                                               else
12926                                                 {
12927                                                   /* 33222222222211111111110000000000
12928                                                      10987654321098765432109876543210
12929                                                      x01001x1101xxxxx010xxxxxxxxxxxxx
12930                                                      ld1sb.  */
12931                                                   return 1559;
12932                                                 }
12933                                             }
12934                                           else
12935                                             {
12936                                               if (((word >> 23) & 0x1) == 0)
12937                                                 {
12938                                                   /* 33222222222211111111110000000000
12939                                                      10987654321098765432109876543210
12940                                                      x01001x1011xxxxx010xxxxxxxxxxxxx
12941                                                      ld1w.  */
12942                                                   return 1590;
12943                                                 }
12944                                               else
12945                                                 {
12946                                                   /* 33222222222211111111110000000000
12947                                                      10987654321098765432109876543210
12948                                                      x01001x1111xxxxx010xxxxxxxxxxxxx
12949                                                      ld1d.  */
12950                                                   return 1512;
12951                                                 }
12952                                             }
12953                                         }
12954                                       else
12955                                         {
12956                                           if (((word >> 22) & 0x1) == 0)
12957                                             {
12958                                               if (((word >> 23) & 0x1) == 0)
12959                                                 {
12960                                                   /* 33222222222211111111110000000000
12961                                                      10987654321098765432109876543210
12962                                                      x01001x1001xxxxx011xxxxxxxxxxxxx
12963                                                      ldff1sh.  */
12964                                                   return 1672;
12965                                                 }
12966                                               else
12967                                                 {
12968                                                   /* 33222222222211111111110000000000
12969                                                      10987654321098765432109876543210
12970                                                      x01001x1101xxxxx011xxxxxxxxxxxxx
12971                                                      ldff1sb.  */
12972                                                   return 1660;
12973                                                 }
12974                                             }
12975                                           else
12976                                             {
12977                                               if (((word >> 23) & 0x1) == 0)
12978                                                 {
12979                                                   /* 33222222222211111111110000000000
12980                                                      10987654321098765432109876543210
12981                                                      x01001x1011xxxxx011xxxxxxxxxxxxx
12982                                                      ldff1w.  */
12983                                                   return 1691;
12984                                                 }
12985                                               else
12986                                                 {
12987                                                   /* 33222222222211111111110000000000
12988                                                      10987654321098765432109876543210
12989                                                      x01001x1111xxxxx011xxxxxxxxxxxxx
12990                                                      ldff1d.  */
12991                                                   return 1636;
12992                                                 }
12993                                             }
12994                                         }
12995                                     }
12996                                 }
12997                               else
12998                                 {
12999                                   if (((word >> 13) & 0x1) == 0)
13000                                     {
13001                                       if (((word >> 31) & 0x1) == 0)
13002                                         {
13003                                           if (((word >> 21) & 0x1) == 0)
13004                                             {
13005                                               if (((word >> 4) & 0x1) == 0)
13006                                                 {
13007                                                   /* 33222222222211111111110000000000
13008                                                      10987654321098765432109876543210
13009                                                      011001x1xx0xxxxx010xxxxxxxx0xxxx
13010                                                      fcmge.  */
13011                                                   return 1391;
13012                                                 }
13013                                               else
13014                                                 {
13015                                                   /* 33222222222211111111110000000000
13016                                                      10987654321098765432109876543210
13017                                                      011001x1xx0xxxxx010xxxxxxxx1xxxx
13018                                                      fcmgt.  */
13019                                                   return 1393;
13020                                                 }
13021                                             }
13022                                           else
13023                                             {
13024                                               /* 33222222222211111111110000000000
13025                                                  10987654321098765432109876543210
13026                                                  011001x1xx1xxxxx010xxxxxxxxxxxxx
13027                                                  fnmla.  */
13028                                               return 1455;
13029                                             }
13030                                         }
13031                                       else
13032                                         {
13033                                           if (((word >> 22) & 0x1) == 0)
13034                                             {
13035                                               /* 33222222222211111111110000000000
13036                                                  10987654321098765432109876543210
13037                                                  111001x1x0xxxxxx010xxxxxxxxxxxxx
13038                                                  str.  */
13039                                               return 1941;
13040                                             }
13041                                           else
13042                                             {
13043                                               if (((word >> 21) & 0x1) == 0)
13044                                                 {
13045                                                   /* 33222222222211111111110000000000
13046                                                      10987654321098765432109876543210
13047                                                      111001x1x10xxxxx010xxxxxxxxxxxxx
13048                                                      st1w.  */
13049                                                   return 1900;
13050                                                 }
13051                                               else
13052                                                 {
13053                                                   if (((word >> 23) & 0x1) == 0)
13054                                                     {
13055                                                       /* 33222222222211111111110000000000
13056                                                          10987654321098765432109876543210
13057                                                          111001x1011xxxxx010xxxxxxxxxxxxx
13058                                                          st1w.  */
13059                                                       return 1902;
13060                                                     }
13061                                                   else
13062                                                     {
13063                                                       /* 33222222222211111111110000000000
13064                                                          10987654321098765432109876543210
13065                                                          111001x1111xxxxx010xxxxxxxxxxxxx
13066                                                          st1d.  */
13067                                                       return 1879;
13068                                                     }
13069                                                 }
13070                                             }
13071                                         }
13072                                     }
13073                                   else
13074                                     {
13075                                       if (((word >> 21) & 0x1) == 0)
13076                                         {
13077                                           if (((word >> 31) & 0x1) == 0)
13078                                             {
13079                                               if (((word >> 4) & 0x1) == 0)
13080                                                 {
13081                                                   /* 33222222222211111111110000000000
13082                                                      10987654321098765432109876543210
13083                                                      011001x1xx0xxxxx011xxxxxxxx0xxxx
13084                                                      fcmeq.  */
13085                                                   return 1389;
13086                                                 }
13087                                               else
13088                                                 {
13089                                                   /* 33222222222211111111110000000000
13090                                                      10987654321098765432109876543210
13091                                                      011001x1xx0xxxxx011xxxxxxxx1xxxx
13092                                                      fcmne.  */
13093                                                   return 1397;
13094                                                 }
13095                                             }
13096                                           else
13097                                             {
13098                                               if (((word >> 22) & 0x1) == 0)
13099                                                 {
13100                                                   if (((word >> 23) & 0x1) == 0)
13101                                                     {
13102                                                       /* 33222222222211111111110000000000
13103                                                          10987654321098765432109876543210
13104                                                          111001x1000xxxxx011xxxxxxxxxxxxx
13105                                                          stnt1w.  */
13106                                                       return 1938;
13107                                                     }
13108                                                   else
13109                                                     {
13110                                                       /* 33222222222211111111110000000000
13111                                                          10987654321098765432109876543210
13112                                                          111001x1100xxxxx011xxxxxxxxxxxxx
13113                                                          stnt1d.  */
13114                                                       return 1934;
13115                                                     }
13116                                                 }
13117                                               else
13118                                                 {
13119                                                   if (((word >> 23) & 0x1) == 0)
13120                                                     {
13121                                                       /* 33222222222211111111110000000000
13122                                                          10987654321098765432109876543210
13123                                                          111001x1010xxxxx011xxxxxxxxxxxxx
13124                                                          st3w.  */
13125                                                       return 1922;
13126                                                     }
13127                                                   else
13128                                                     {
13129                                                       /* 33222222222211111111110000000000
13130                                                          10987654321098765432109876543210
13131                                                          111001x1110xxxxx011xxxxxxxxxxxxx
13132                                                          st3d.  */
13133                                                       return 1918;
13134                                                     }
13135                                                 }
13136                                             }
13137                                         }
13138                                       else
13139                                         {
13140                                           if (((word >> 31) & 0x1) == 0)
13141                                             {
13142                                               /* 33222222222211111111110000000000
13143                                                  10987654321098765432109876543210
13144                                                  011001x1xx1xxxxx011xxxxxxxxxxxxx
13145                                                  fnmls.  */
13146                                               return 1456;
13147                                             }
13148                                           else
13149                                             {
13150                                               if (((word >> 22) & 0x1) == 0)
13151                                                 {
13152                                                   if (((word >> 23) & 0x1) == 0)
13153                                                     {
13154                                                       /* 33222222222211111111110000000000
13155                                                          10987654321098765432109876543210
13156                                                          111001x1001xxxxx011xxxxxxxxxxxxx
13157                                                          st2w.  */
13158                                                       return 1914;
13159                                                     }
13160                                                   else
13161                                                     {
13162                                                       /* 33222222222211111111110000000000
13163                                                          10987654321098765432109876543210
13164                                                          111001x1101xxxxx011xxxxxxxxxxxxx
13165                                                          st2d.  */
13166                                                       return 1910;
13167                                                     }
13168                                                 }
13169                                               else
13170                                                 {
13171                                                   if (((word >> 23) & 0x1) == 0)
13172                                                     {
13173                                                       /* 33222222222211111111110000000000
13174                                                          10987654321098765432109876543210
13175                                                          111001x1011xxxxx011xxxxxxxxxxxxx
13176                                                          st4w.  */
13177                                                       return 1930;
13178                                                     }
13179                                                   else
13180                                                     {
13181                                                       /* 33222222222211111111110000000000
13182                                                          10987654321098765432109876543210
13183                                                          111001x1111xxxxx011xxxxxxxxxxxxx
13184                                                          st4d.  */
13185                                                       return 1926;
13186                                                     }
13187                                                 }
13188                                             }
13189                                         }
13190                                     }
13191                                 }
13192                             }
13193                         }
13194                       else
13195                         {
13196                           if (((word >> 21) & 0x1) == 0)
13197                             {
13198                               if (((word >> 30) & 0x1) == 0)
13199                                 {
13200                                   if (((word >> 14) & 0x1) == 0)
13201                                     {
13202                                       if (((word >> 13) & 0x1) == 0)
13203                                         {
13204                                           if (((word >> 4) & 0x1) == 0)
13205                                             {
13206                                               /* 33222222222211111111110000000000
13207                                                  10987654321098765432109876543210
13208                                                  x01001x1xx0xxxxx100xxxxxxxx0xxxx
13209                                                  cmpeq.  */
13210                                               return 1318;
13211                                             }
13212                                           else
13213                                             {
13214                                               /* 33222222222211111111110000000000
13215                                                  10987654321098765432109876543210
13216                                                  x01001x1xx0xxxxx100xxxxxxxx1xxxx
13217                                                  cmpne.  */
13218                                               return 1341;
13219                                             }
13220                                         }
13221                                       else
13222                                         {
13223                                           if (((word >> 20) & 0x1) == 0)
13224                                             {
13225                                               if (((word >> 22) & 0x1) == 0)
13226                                                 {
13227                                                   if (((word >> 23) & 0x1) == 0)
13228                                                     {
13229                                                       /* 33222222222211111111110000000000
13230                                                          10987654321098765432109876543210
13231                                                          x01001x10000xxxx101xxxxxxxxxxxxx
13232                                                          ld1sh.  */
13233                                                       return 1577;
13234                                                     }
13235                                                   else
13236                                                     {
13237                                                       /* 33222222222211111111110000000000
13238                                                          10987654321098765432109876543210
13239                                                          x01001x11000xxxx101xxxxxxxxxxxxx
13240                                                          ld1sb.  */
13241                                                       return 1564;
13242                                                     }
13243                                                 }
13244                                               else
13245                                                 {
13246                                                   if (((word >> 23) & 0x1) == 0)
13247                                                     {
13248                                                       /* 33222222222211111111110000000000
13249                                                          10987654321098765432109876543210
13250                                                          x01001x10100xxxx101xxxxxxxxxxxxx
13251                                                          ld1w.  */
13252                                                       return 1596;
13253                                                     }
13254                                                   else
13255                                                     {
13256                                                       /* 33222222222211111111110000000000
13257                                                          10987654321098765432109876543210
13258                                                          x01001x11100xxxx101xxxxxxxxxxxxx
13259                                                          ld1sb.  */
13260                                                       return 1566;
13261                                                     }
13262                                                 }
13263                                             }
13264                                           else
13265                                             {
13266                                               if (((word >> 22) & 0x1) == 0)
13267                                                 {
13268                                                   if (((word >> 23) & 0x1) == 0)
13269                                                     {
13270                                                       /* 33222222222211111111110000000000
13271                                                          10987654321098765432109876543210
13272                                                          x01001x10001xxxx101xxxxxxxxxxxxx
13273                                                          ldnf1sh.  */
13274                                                       return 1710;
13275                                                     }
13276                                                   else
13277                                                     {
13278                                                       /* 33222222222211111111110000000000
13279                                                          10987654321098765432109876543210
13280                                                          x01001x11001xxxx101xxxxxxxxxxxxx
13281                                                          ldnf1sb.  */
13282                                                       return 1707;
13283                                                     }
13284                                                 }
13285                                               else
13286                                                 {
13287                                                   if (((word >> 23) & 0x1) == 0)
13288                                                     {
13289                                                       /* 33222222222211111111110000000000
13290                                                          10987654321098765432109876543210
13291                                                          x01001x10101xxxx101xxxxxxxxxxxxx
13292                                                          ldnf1w.  */
13293                                                       return 1713;
13294                                                     }
13295                                                   else
13296                                                     {
13297                                                       /* 33222222222211111111110000000000
13298                                                          10987654321098765432109876543210
13299                                                          x01001x11101xxxx101xxxxxxxxxxxxx
13300                                                          ldnf1sb.  */
13301                                                       return 1709;
13302                                                     }
13303                                                 }
13304                                             }
13305                                         }
13306                                     }
13307                                   else
13308                                     {
13309                                       if (((word >> 31) & 0x1) == 0)
13310                                         {
13311                                           if (((word >> 4) & 0x1) == 0)
13312                                             {
13313                                               if (((word >> 20) & 0x1) == 0)
13314                                                 {
13315                                                   if (((word >> 22) & 0x1) == 0)
13316                                                     {
13317                                                       /* 33222222222211111111110000000000
13318                                                          10987654321098765432109876543210
13319                                                          001001x1x000xxxx11xxxxxxxxx0xxxx
13320                                                          brkpa.  */
13321                                                       return 1304;
13322                                                     }
13323                                                   else
13324                                                     {
13325                                                       /* 33222222222211111111110000000000
13326                                                          10987654321098765432109876543210
13327                                                          001001x1x100xxxx11xxxxxxxxx0xxxx
13328                                                          brkpas.  */
13329                                                       return 1305;
13330                                                     }
13331                                                 }
13332                                               else
13333                                                 {
13334                                                   if (((word >> 16) & 0x1) == 0)
13335                                                     {
13336                                                       if (((word >> 19) & 0x1) == 0)
13337                                                         {
13338                                                           /* 33222222222211111111110000000000
13339                                                              10987654321098765432109876543210
13340                                                              001001x1xx010xx011xxxxxxxxx0xxxx
13341                                                              ptest.  */
13342                                                           return 1790;
13343                                                         }
13344                                                       else
13345                                                         {
13346                                                           if (((word >> 10) & 0x1) == 0)
13347                                                             {
13348                                                               if (((word >> 12) & 0x1) == 0)
13349                                                                 {
13350                                                                   if (((word >> 13) & 0x1) == 0)
13351                                                                     {
13352                                                                       /* 33222222222211111111110000000000
13353                                                                          10987654321098765432109876543210
13354                                                                          001001x1xx011xx01100x0xxxxx0xxxx
13355                                                                          pfirst.  */
13356                                                                       return 1760;
13357                                                                     }
13358                                                                   else
13359                                                                     {
13360                                                                       /* 33222222222211111111110000000000
13361                                                                          10987654321098765432109876543210
13362                                                                          001001x1xx011xx01110x0xxxxx0xxxx
13363                                                                          ptrue.  */
13364                                                                       return 1791;
13365                                                                     }
13366                                                                 }
13367                                                               else
13368                                                                 {
13369                                                                   if (((word >> 22) & 0x1) == 0)
13370                                                                     {
13371                                                                       /* 33222222222211111111110000000000
13372                                                                          10987654321098765432109876543210
13373                                                                          001001x1x0011xx011x1x0xxxxx0xxxx
13374                                                                          rdffr.  */
13375                                                                       return 1797;
13376                                                                     }
13377                                                                   else
13378                                                                     {
13379                                                                       /* 33222222222211111111110000000000
13380                                                                          10987654321098765432109876543210
13381                                                                          001001x1x1011xx011x1x0xxxxx0xxxx
13382                                                                          rdffrs.  */
13383                                                                       return 1798;
13384                                                                     }
13385                                                                 }
13386                                                             }
13387                                                           else
13388                                                             {
13389                                                               /* 33222222222211111111110000000000
13390                                                                  10987654321098765432109876543210
13391                                                                  001001x1xx011xx011xxx1xxxxx0xxxx
13392                                                                  pfalse.  */
13393                                                               return 1759;
13394                                                             }
13395                                                         }
13396                                                     }
13397                                                   else
13398                                                     {
13399                                                       if (((word >> 10) & 0x1) == 0)
13400                                                         {
13401                                                           if (((word >> 12) & 0x1) == 0)
13402                                                             {
13403                                                               /* 33222222222211111111110000000000
13404                                                                  10987654321098765432109876543210
13405                                                                  001001x1xx01xxx111x0x0xxxxx0xxxx
13406                                                                  ptrues.  */
13407                                                               return 1792;
13408                                                             }
13409                                                           else
13410                                                             {
13411                                                               /* 33222222222211111111110000000000
13412                                                                  10987654321098765432109876543210
13413                                                                  001001x1xx01xxx111x1x0xxxxx0xxxx
13414                                                                  rdffr.  */
13415                                                               return 1796;
13416                                                             }
13417                                                         }
13418                                                       else
13419                                                         {
13420                                                           /* 33222222222211111111110000000000
13421                                                              10987654321098765432109876543210
13422                                                              001001x1xx01xxx111xxx1xxxxx0xxxx
13423                                                              pnext.  */
13424                                                           return 1761;
13425                                                         }
13426                                                     }
13427                                                 }
13428                                             }
13429                                           else
13430                                             {
13431                                               if (((word >> 22) & 0x1) == 0)
13432                                                 {
13433                                                   /* 33222222222211111111110000000000
13434                                                      10987654321098765432109876543210
13435                                                      001001x1x00xxxxx11xxxxxxxxx1xxxx
13436                                                      brkpb.  */
13437                                                   return 1306;
13438                                                 }
13439                                               else
13440                                                 {
13441                                                   /* 33222222222211111111110000000000
13442                                                      10987654321098765432109876543210
13443                                                      001001x1x10xxxxx11xxxxxxxxx1xxxx
13444                                                      brkpbs.  */
13445                                                   return 1307;
13446                                                 }
13447                                             }
13448                                         }
13449                                       else
13450                                         {
13451                                           if (((word >> 13) & 0x1) == 0)
13452                                             {
13453                                               if (((word >> 22) & 0x1) == 0)
13454                                                 {
13455                                                   if (((word >> 23) & 0x1) == 0)
13456                                                     {
13457                                                       /* 33222222222211111111110000000000
13458                                                          10987654321098765432109876543210
13459                                                          101001x1000xxxxx110xxxxxxxxxxxxx
13460                                                          ldnt1w.  */
13461                                                       return 1721;
13462                                                     }
13463                                                   else
13464                                                     {
13465                                                       /* 33222222222211111111110000000000
13466                                                          10987654321098765432109876543210
13467                                                          101001x1100xxxxx110xxxxxxxxxxxxx
13468                                                          ldnt1d.  */
13469                                                       return 1717;
13470                                                     }
13471                                                 }
13472                                               else
13473                                                 {
13474                                                   if (((word >> 23) & 0x1) == 0)
13475                                                     {
13476                                                       /* 33222222222211111111110000000000
13477                                                          10987654321098765432109876543210
13478                                                          101001x1010xxxxx110xxxxxxxxxxxxx
13479                                                          ld3w.  */
13480                                                       return 1613;
13481                                                     }
13482                                                   else
13483                                                     {
13484                                                       /* 33222222222211111111110000000000
13485                                                          10987654321098765432109876543210
13486                                                          101001x1110xxxxx110xxxxxxxxxxxxx
13487                                                          ld3d.  */
13488                                                       return 1609;
13489                                                     }
13490                                                 }
13491                                             }
13492                                           else
13493                                             {
13494                                               if (((word >> 22) & 0x1) == 0)
13495                                                 {
13496                                                   if (((word >> 23) & 0x1) == 0)
13497                                                     {
13498                                                       /* 33222222222211111111110000000000
13499                                                          10987654321098765432109876543210
13500                                                          101001x1000xxxxx111xxxxxxxxxxxxx
13501                                                          ldnt1w.  */
13502                                                       return 1722;
13503                                                     }
13504                                                   else
13505                                                     {
13506                                                       /* 33222222222211111111110000000000
13507                                                          10987654321098765432109876543210
13508                                                          101001x1100xxxxx111xxxxxxxxxxxxx
13509                                                          ldnt1d.  */
13510                                                       return 1718;
13511                                                     }
13512                                                 }
13513                                               else
13514                                                 {
13515                                                   if (((word >> 23) & 0x1) == 0)
13516                                                     {
13517                                                       /* 33222222222211111111110000000000
13518                                                          10987654321098765432109876543210
13519                                                          101001x1010xxxxx111xxxxxxxxxxxxx
13520                                                          ld3w.  */
13521                                                       return 1614;
13522                                                     }
13523                                                   else
13524                                                     {
13525                                                       /* 33222222222211111111110000000000
13526                                                          10987654321098765432109876543210
13527                                                          101001x1110xxxxx111xxxxxxxxxxxxx
13528                                                          ld3d.  */
13529                                                       return 1610;
13530                                                     }
13531                                                 }
13532                                             }
13533                                         }
13534                                     }
13535                                 }
13536                               else
13537                                 {
13538                                   if (((word >> 13) & 0x1) == 0)
13539                                     {
13540                                       if (((word >> 31) & 0x1) == 0)
13541                                         {
13542                                           if (((word >> 14) & 0x1) == 0)
13543                                             {
13544                                               if (((word >> 19) & 0x1) == 0)
13545                                                 {
13546                                                   if (((word >> 20) & 0x1) == 0)
13547                                                     {
13548                                                       if (((word >> 16) & 0x1) == 0)
13549                                                         {
13550                                                           if (((word >> 17) & 0x1) == 0)
13551                                                             {
13552                                                               if (((word >> 18) & 0x1) == 0)
13553                                                                 {
13554                                                                   /* 33222222222211111111110000000000
13555                                                                      10987654321098765432109876543210
13556                                                                      011001x1xx000000100xxxxxxxxxxxxx
13557                                                                      fadd.  */
13558                                                                   return 1380;
13559                                                                 }
13560                                                               else
13561                                                                 {
13562                                                                   /* 33222222222211111111110000000000
13563                                                                      10987654321098765432109876543210
13564                                                                      011001x1xx000100100xxxxxxxxxxxxx
13565                                                                      fmaxnm.  */
13566                                                                   return 1427;
13567                                                                 }
13568                                                             }
13569                                                           else
13570                                                             {
13571                                                               if (((word >> 18) & 0x1) == 0)
13572                                                                 {
13573                                                                   /* 33222222222211111111110000000000
13574                                                                      10987654321098765432109876543210
13575                                                                      011001x1xx000010100xxxxxxxxxxxxx
13576                                                                      fmul.  */
13577                                                                   return 1447;
13578                                                                 }
13579                                                               else
13580                                                                 {
13581                                                                   /* 33222222222211111111110000000000
13582                                                                      10987654321098765432109876543210
13583                                                                      011001x1xx000110100xxxxxxxxxxxxx
13584                                                                      fmax.  */
13585                                                                   return 1425;
13586                                                                 }
13587                                                             }
13588                                                         }
13589                                                       else
13590                                                         {
13591                                                           if (((word >> 17) & 0x1) == 0)
13592                                                             {
13593                                                               if (((word >> 18) & 0x1) == 0)
13594                                                                 {
13595                                                                   /* 33222222222211111111110000000000
13596                                                                      10987654321098765432109876543210
13597                                                                      011001x1xx000001100xxxxxxxxxxxxx
13598                                                                      fsub.  */
13599                                                                   return 1473;
13600                                                                 }
13601                                                               else
13602                                                                 {
13603                                                                   /* 33222222222211111111110000000000
13604                                                                      10987654321098765432109876543210
13605                                                                      011001x1xx000101100xxxxxxxxxxxxx
13606                                                                      fminnm.  */
13607                                                                   return 1433;
13608                                                                 }
13609                                                             }
13610                                                           else
13611                                                             {
13612                                                               if (((word >> 18) & 0x1) == 0)
13613                                                                 {
13614                                                                   /* 33222222222211111111110000000000
13615                                                                      10987654321098765432109876543210
13616                                                                      011001x1xx000011100xxxxxxxxxxxxx
13617                                                                      fsubr.  */
13618                                                                   return 1475;
13619                                                                 }
13620                                                               else
13621                                                                 {
13622                                                                   /* 33222222222211111111110000000000
13623                                                                      10987654321098765432109876543210
13624                                                                      011001x1xx000111100xxxxxxxxxxxxx
13625                                                                      fmin.  */
13626                                                                   return 1431;
13627                                                                 }
13628                                                             }
13629                                                         }
13630                                                     }
13631                                                   else
13632                                                     {
13633                                                       /* 33222222222211111111110000000000
13634                                                          10987654321098765432109876543210
13635                                                          011001x1xx010xxx100xxxxxxxxxxxxx
13636                                                          ftmad.  */
13637                                                       return 1477;
13638                                                     }
13639                                                 }
13640                                               else
13641                                                 {
13642                                                   if (((word >> 16) & 0x1) == 0)
13643                                                     {
13644                                                       if (((word >> 17) & 0x1) == 0)
13645                                                         {
13646                                                           if (((word >> 18) & 0x1) == 0)
13647                                                             {
13648                                                               if (((word >> 20) & 0x1) == 0)
13649                                                                 {
13650                                                                   /* 33222222222211111111110000000000
13651                                                                      10987654321098765432109876543210
13652                                                                      011001x1xx001000100xxxxxxxxxxxxx
13653                                                                      fabd.  */
13654                                                                   return 1375;
13655                                                                 }
13656                                                               else
13657                                                                 {
13658                                                                   /* 33222222222211111111110000000000
13659                                                                      10987654321098765432109876543210
13660                                                                      011001x1xx011000100xxxxxxxxxxxxx
13661                                                                      fadd.  */
13662                                                                   return 1381;
13663                                                                 }
13664                                                             }
13665                                                           else
13666                                                             {
13667                                                               if (((word >> 20) & 0x1) == 0)
13668                                                                 {
13669                                                                   /* 33222222222211111111110000000000
13670                                                                      10987654321098765432109876543210
13671                                                                      011001x1xx001100100xxxxxxxxxxxxx
13672                                                                      fdivr.  */
13673                                                                   return 1421;
13674                                                                 }
13675                                                               else
13676                                                                 {
13677                                                                   /* 33222222222211111111110000000000
13678                                                                      10987654321098765432109876543210
13679                                                                      011001x1xx011100100xxxxxxxxxxxxx
13680                                                                      fmaxnm.  */
13681                                                                   return 1428;
13682                                                                 }
13683                                                             }
13684                                                         }
13685                                                       else
13686                                                         {
13687                                                           if (((word >> 18) & 0x1) == 0)
13688                                                             {
13689                                                               if (((word >> 20) & 0x1) == 0)
13690                                                                 {
13691                                                                   /* 33222222222211111111110000000000
13692                                                                      10987654321098765432109876543210
13693                                                                      011001x1xx001010100xxxxxxxxxxxxx
13694                                                                      fmulx.  */
13695                                                                   return 1452;
13696                                                                 }
13697                                                               else
13698                                                                 {
13699                                                                   /* 33222222222211111111110000000000
13700                                                                      10987654321098765432109876543210
13701                                                                      011001x1xx011010100xxxxxxxxxxxxx
13702                                                                      fmul.  */
13703                                                                   return 1448;
13704                                                                 }
13705                                                             }
13706                                                           else
13707                                                             {
13708                                                               /* 33222222222211111111110000000000
13709                                                                  10987654321098765432109876543210
13710                                                                  011001x1xx0x1110100xxxxxxxxxxxxx
13711                                                                  fmax.  */
13712                                                               return 1426;
13713                                                             }
13714                                                         }
13715                                                     }
13716                                                   else
13717                                                     {
13718                                                       if (((word >> 17) & 0x1) == 0)
13719                                                         {
13720                                                           if (((word >> 18) & 0x1) == 0)
13721                                                             {
13722                                                               if (((word >> 20) & 0x1) == 0)
13723                                                                 {
13724                                                                   /* 33222222222211111111110000000000
13725                                                                      10987654321098765432109876543210
13726                                                                      011001x1xx001001100xxxxxxxxxxxxx
13727                                                                      fscale.  */
13728                                                                   return 1470;
13729                                                                 }
13730                                                               else
13731                                                                 {
13732                                                                   /* 33222222222211111111110000000000
13733                                                                      10987654321098765432109876543210
13734                                                                      011001x1xx011001100xxxxxxxxxxxxx
13735                                                                      fsub.  */
13736                                                                   return 1474;
13737                                                                 }
13738                                                             }
13739                                                           else
13740                                                             {
13741                                                               if (((word >> 20) & 0x1) == 0)
13742                                                                 {
13743                                                                   /* 33222222222211111111110000000000
13744                                                                      10987654321098765432109876543210
13745                                                                      011001x1xx001101100xxxxxxxxxxxxx
13746                                                                      fdiv.  */
13747                                                                   return 1420;
13748                                                                 }
13749                                                               else
13750                                                                 {
13751                                                                   /* 33222222222211111111110000000000
13752                                                                      10987654321098765432109876543210
13753                                                                      011001x1xx011101100xxxxxxxxxxxxx
13754                                                                      fminnm.  */
13755                                                                   return 1434;
13756                                                                 }
13757                                                             }
13758                                                         }
13759                                                       else
13760                                                         {
13761                                                           if (((word >> 18) & 0x1) == 0)
13762                                                             {
13763                                                               /* 33222222222211111111110000000000
13764                                                                  10987654321098765432109876543210
13765                                                                  011001x1xx0x1011100xxxxxxxxxxxxx
13766                                                                  fsubr.  */
13767                                                               return 1476;
13768                                                             }
13769                                                           else
13770                                                             {
13771                                                               /* 33222222222211111111110000000000
13772                                                                  10987654321098765432109876543210
13773                                                                  011001x1xx0x1111100xxxxxxxxxxxxx
13774                                                                  fmin.  */
13775                                                               return 1432;
13776                                                             }
13777                                                         }
13778                                                     }
13779                                                 }
13780                                             }
13781                                           else
13782                                             {
13783                                               if (((word >> 4) & 0x1) == 0)
13784                                                 {
13785                                                   /* 33222222222211111111110000000000
13786                                                      10987654321098765432109876543210
13787                                                      011001x1xx0xxxxx110xxxxxxxx0xxxx
13788                                                      fcmuo.  */
13789                                                   return 1398;
13790                                                 }
13791                                               else
13792                                                 {
13793                                                   /* 33222222222211111111110000000000
13794                                                      10987654321098765432109876543210
13795                                                      011001x1xx0xxxxx110xxxxxxxx1xxxx
13796                                                      facge.  */
13797                                                   return 1377;
13798                                                 }
13799                                             }
13800                                         }
13801                                       else
13802                                         {
13803                                           if (((word >> 22) & 0x1) == 0)
13804                                             {
13805                                               if (((word >> 23) & 0x1) == 0)
13806                                                 {
13807                                                   /* 33222222222211111111110000000000
13808                                                      10987654321098765432109876543210
13809                                                      111001x1000xxxxx1x0xxxxxxxxxxxxx
13810                                                      st1w.  */
13811                                                   return 1896;
13812                                                 }
13813                                               else
13814                                                 {
13815                                                   /* 33222222222211111111110000000000
13816                                                      10987654321098765432109876543210
13817                                                      111001x1100xxxxx1x0xxxxxxxxxxxxx
13818                                                      st1d.  */
13819                                                   return 1875;
13820                                                 }
13821                                             }
13822                                           else
13823                                             {
13824                                               /* 33222222222211111111110000000000
13825                                                  10987654321098765432109876543210
13826                                                  111001x1x10xxxxx1x0xxxxxxxxxxxxx
13827                                                  st1w.  */
13828                                               return 1901;
13829                                             }
13830                                         }
13831                                     }
13832                                   else
13833                                     {
13834                                       if (((word >> 14) & 0x1) == 0)
13835                                         {
13836                                           if (((word >> 31) & 0x1) == 0)
13837                                             {
13838                                               if (((word >> 16) & 0x1) == 0)
13839                                                 {
13840                                                   if (((word >> 19) & 0x1) == 0)
13841                                                     {
13842                                                       if (((word >> 17) & 0x1) == 0)
13843                                                         {
13844                                                           if (((word >> 18) & 0x1) == 0)
13845                                                             {
13846                                                               if (((word >> 20) & 0x1) == 0)
13847                                                                 {
13848                                                                   /* 33222222222211111111110000000000
13849                                                                      10987654321098765432109876543210
13850                                                                      011001x1xx000000101xxxxxxxxxxxxx
13851                                                                      frintn.  */
13852                                                                   return 1464;
13853                                                                 }
13854                                                               else
13855                                                                 {
13856                                                                   /* 33222222222211111111110000000000
13857                                                                      10987654321098765432109876543210
13858                                                                      011001x1xx010000101xxxxxxxxxxxxx
13859                                                                      scvtf.  */
13860                                                                   return 1810;
13861                                                                 }
13862                                                             }
13863                                                           else
13864                                                             {
13865                                                               if (((word >> 20) & 0x1) == 0)
13866                                                                 {
13867                                                                   /* 33222222222211111111110000000000
13868                                                                      10987654321098765432109876543210
13869                                                                      011001x1xx000100101xxxxxxxxxxxxx
13870                                                                      frinta.  */
13871                                                                   return 1461;
13872                                                                 }
13873                                                               else
13874                                                                 {
13875                                                                   if (((word >> 22) & 0x1) == 0)
13876                                                                     {
13877                                                                       /* 33222222222211111111110000000000
13878                                                                          10987654321098765432109876543210
13879                                                                          011001x1x0010100101xxxxxxxxxxxxx
13880                                                                          scvtf.  */
13881                                                                       return 1809;
13882                                                                     }
13883                                                                   else
13884                                                                     {
13885                                                                       if (((word >> 23) & 0x1) == 0)
13886                                                                         {
13887                                                                           /* 33222222222211111111110000000000
13888                                                                              10987654321098765432109876543210
13889                                                                              011001x101010100101xxxxxxxxxxxxx
13890                                                                              scvtf.  */
13891                                                                           return 1808;
13892                                                                         }
13893                                                                       else
13894                                                                         {
13895                                                                           /* 33222222222211111111110000000000
13896                                                                              10987654321098765432109876543210
13897                                                                              011001x111010100101xxxxxxxxxxxxx
13898                                                                              scvtf.  */
13899                                                                           return 1812;
13900                                                                         }
13901                                                                     }
13902                                                                 }
13903                                                             }
13904                                                         }
13905                                                       else
13906                                                         {
13907                                                           if (((word >> 18) & 0x1) == 0)
13908                                                             {
13909                                                               if (((word >> 20) & 0x1) == 0)
13910                                                                 {
13911                                                                   /* 33222222222211111111110000000000
13912                                                                      10987654321098765432109876543210
13913                                                                      011001x1xx000010101xxxxxxxxxxxxx
13914                                                                      frintm.  */
13915                                                                   return 1463;
13916                                                                 }
13917                                                               else
13918                                                                 {
13919                                                                   /* 33222222222211111111110000000000
13920                                                                      10987654321098765432109876543210
13921                                                                      011001x1xx010010101xxxxxxxxxxxxx
13922                                                                      scvtf.  */
13923                                                                   return 1807;
13924                                                                 }
13925                                                             }
13926                                                           else
13927                                                             {
13928                                                               if (((word >> 20) & 0x1) == 0)
13929                                                                 {
13930                                                                   /* 33222222222211111111110000000000
13931                                                                      10987654321098765432109876543210
13932                                                                      011001x1xx000110101xxxxxxxxxxxxx
13933                                                                      frintx.  */
13934                                                                   return 1466;
13935                                                                 }
13936                                                               else
13937                                                                 {
13938                                                                   if (((word >> 23) & 0x1) == 0)
13939                                                                     {
13940                                                                       /* 33222222222211111111110000000000
13941                                                                          10987654321098765432109876543210
13942                                                                          011001x10x010110101xxxxxxxxxxxxx
13943                                                                          scvtf.  */
13944                                                                       return 1811;
13945                                                                     }
13946                                                                   else
13947                                                                     {
13948                                                                       /* 33222222222211111111110000000000
13949                                                                          10987654321098765432109876543210
13950                                                                          011001x11x010110101xxxxxxxxxxxxx
13951                                                                          scvtf.  */
13952                                                                       return 1813;
13953                                                                     }
13954                                                                 }
13955                                                             }
13956                                                         }
13957                                                     }
13958                                                   else
13959                                                     {
13960                                                       if (((word >> 20) & 0x1) == 0)
13961                                                         {
13962                                                           if (((word >> 17) & 0x1) == 0)
13963                                                             {
13964                                                               if (((word >> 18) & 0x1) == 0)
13965                                                                 {
13966                                                                   if (((word >> 22) & 0x1) == 0)
13967                                                                     {
13968                                                                       /* 33222222222211111111110000000000
13969                                                                          10987654321098765432109876543210
13970                                                                          011001x1x0001000101xxxxxxxxxxxxx
13971                                                                          fcvt.  */
13972                                                                       return 1400;
13973                                                                     }
13974                                                                   else
13975                                                                     {
13976                                                                       /* 33222222222211111111110000000000
13977                                                                          10987654321098765432109876543210
13978                                                                          011001x1x1001000101xxxxxxxxxxxxx
13979                                                                          fcvt.  */
13980                                                                       return 1402;
13981                                                                     }
13982                                                                 }
13983                                                               else
13984                                                                 {
13985                                                                   /* 33222222222211111111110000000000
13986                                                                      10987654321098765432109876543210
13987                                                                      011001x1xx001100101xxxxxxxxxxxxx
13988                                                                      frecpx.  */
13989                                                                   return 1460;
13990                                                                 }
13991                                                             }
13992                                                           else
13993                                                             {
13994                                                               if (((word >> 22) & 0x1) == 0)
13995                                                                 {
13996                                                                   /* 33222222222211111111110000000000
13997                                                                      10987654321098765432109876543210
13998                                                                      011001x1x0001x10101xxxxxxxxxxxxx
13999                                                                      fcvtx.  */
14000                                                                   return 2070;
14001                                                                 }
14002                                                               else
14003                                                                 {
14004                                                                   /* 33222222222211111111110000000000
14005                                                                      10987654321098765432109876543210
14006                                                                      011001x1x1001x10101xxxxxxxxxxxxx
14007                                                                      fcvt.  */
14008                                                                   return 1404;
14009                                                                 }
14010                                                             }
14011                                                         }
14012                                                       else
14013                                                         {
14014                                                           if (((word >> 22) & 0x1) == 0)
14015                                                             {
14016                                                               if (((word >> 23) & 0x1) == 0)
14017                                                                 {
14018                                                                   /* 33222222222211111111110000000000
14019                                                                      10987654321098765432109876543210
14020                                                                      011001x100011xx0101xxxxxxxxxxxxx
14021                                                                      flogb.  */
14022                                                                   return 2072;
14023                                                                 }
14024                                                               else
14025                                                                 {
14026                                                                   /* 33222222222211111111110000000000
14027                                                                      10987654321098765432109876543210
14028                                                                      011001x110011xx0101xxxxxxxxxxxxx
14029                                                                      fcvtzs.  */
14030                                                                   return 1409;
14031                                                                 }
14032                                                             }
14033                                                           else
14034                                                             {
14035                                                               if (((word >> 17) & 0x1) == 0)
14036                                                                 {
14037                                                                   if (((word >> 18) & 0x1) == 0)
14038                                                                     {
14039                                                                       /* 33222222222211111111110000000000
14040                                                                          10987654321098765432109876543210
14041                                                                          011001x1x1011000101xxxxxxxxxxxxx
14042                                                                          fcvtzs.  */
14043                                                                       return 1410;
14044                                                                     }
14045                                                                   else
14046                                                                     {
14047                                                                       if (((word >> 23) & 0x1) == 0)
14048                                                                         {
14049                                                                           /* 33222222222211111111110000000000
14050                                                                              10987654321098765432109876543210
14051                                                                              011001x101011100101xxxxxxxxxxxxx
14052                                                                              fcvtzs.  */
14053                                                                           return 1407;
14054                                                                         }
14055                                                                       else
14056                                                                         {
14057                                                                           /* 33222222222211111111110000000000
14058                                                                              10987654321098765432109876543210
14059                                                                              011001x111011100101xxxxxxxxxxxxx
14060                                                                              fcvtzs.  */
14061                                                                           return 1411;
14062                                                                         }
14063                                                                     }
14064                                                                 }
14065                                                               else
14066                                                                 {
14067                                                                   if (((word >> 18) & 0x1) == 0)
14068                                                                     {
14069                                                                       /* 33222222222211111111110000000000
14070                                                                          10987654321098765432109876543210
14071                                                                          011001x1x1011010101xxxxxxxxxxxxx
14072                                                                          fcvtzs.  */
14073                                                                       return 1406;
14074                                                                     }
14075                                                                   else
14076                                                                     {
14077                                                                       if (((word >> 23) & 0x1) == 0)
14078                                                                         {
14079                                                                           /* 33222222222211111111110000000000
14080                                                                              10987654321098765432109876543210
14081                                                                              011001x101011110101xxxxxxxxxxxxx
14082                                                                              fcvtzs.  */
14083                                                                           return 1408;
14084                                                                         }
14085                                                                       else
14086                                                                         {
14087                                                                           /* 33222222222211111111110000000000
14088                                                                              10987654321098765432109876543210
14089                                                                              011001x111011110101xxxxxxxxxxxxx
14090                                                                              fcvtzs.  */
14091                                                                           return 1412;
14092                                                                         }
14093                                                                     }
14094                                                                 }
14095                                                             }
14096                                                         }
14097                                                     }
14098                                                 }
14099                                               else
14100                                                 {
14101                                                   if (((word >> 17) & 0x1) == 0)
14102                                                     {
14103                                                       if (((word >> 18) & 0x1) == 0)
14104                                                         {
14105                                                           if (((word >> 19) & 0x1) == 0)
14106                                                             {
14107                                                               if (((word >> 20) & 0x1) == 0)
14108                                                                 {
14109                                                                   /* 33222222222211111111110000000000
14110                                                                      10987654321098765432109876543210
14111                                                                      011001x1xx000001101xxxxxxxxxxxxx
14112                                                                      frintp.  */
14113                                                                   return 1465;
14114                                                                 }
14115                                                               else
14116                                                                 {
14117                                                                   /* 33222222222211111111110000000000
14118                                                                      10987654321098765432109876543210
14119                                                                      011001x1xx010001101xxxxxxxxxxxxx
14120                                                                      ucvtf.  */
14121                                                                   return 1962;
14122                                                                 }
14123                                                             }
14124                                                           else
14125                                                             {
14126                                                               if (((word >> 20) & 0x1) == 0)
14127                                                                 {
14128                                                                   if (((word >> 22) & 0x1) == 0)
14129                                                                     {
14130                                                                       /* 33222222222211111111110000000000
14131                                                                          10987654321098765432109876543210
14132                                                                          011001x1x0001001101xxxxxxxxxxxxx
14133                                                                          fcvt.  */
14134                                                                       return 1401;
14135                                                                     }
14136                                                                   else
14137                                                                     {
14138                                                                       /* 33222222222211111111110000000000
14139                                                                          10987654321098765432109876543210
14140                                                                          011001x1x1001001101xxxxxxxxxxxxx
14141                                                                          fcvt.  */
14142                                                                       return 1403;
14143                                                                     }
14144                                                                 }
14145                                                               else
14146                                                                 {
14147                                                                   /* 33222222222211111111110000000000
14148                                                                      10987654321098765432109876543210
14149                                                                      011001x1xx011001101xxxxxxxxxxxxx
14150                                                                      fcvtzu.  */
14151                                                                   return 1417;
14152                                                                 }
14153                                                             }
14154                                                         }
14155                                                       else
14156                                                         {
14157                                                           if (((word >> 19) & 0x1) == 0)
14158                                                             {
14159                                                               if (((word >> 22) & 0x1) == 0)
14160                                                                 {
14161                                                                   /* 33222222222211111111110000000000
14162                                                                      10987654321098765432109876543210
14163                                                                      011001x1x00x0101101xxxxxxxxxxxxx
14164                                                                      ucvtf.  */
14165                                                                   return 1961;
14166                                                                 }
14167                                                               else
14168                                                                 {
14169                                                                   if (((word >> 23) & 0x1) == 0)
14170                                                                     {
14171                                                                       /* 33222222222211111111110000000000
14172                                                                          10987654321098765432109876543210
14173                                                                          011001x1010x0101101xxxxxxxxxxxxx
14174                                                                          ucvtf.  */
14175                                                                       return 1960;
14176                                                                     }
14177                                                                   else
14178                                                                     {
14179                                                                       /* 33222222222211111111110000000000
14180                                                                          10987654321098765432109876543210
14181                                                                          011001x1110x0101101xxxxxxxxxxxxx
14182                                                                          ucvtf.  */
14183                                                                       return 1964;
14184                                                                     }
14185                                                                 }
14186                                                             }
14187                                                           else
14188                                                             {
14189                                                               if (((word >> 20) & 0x1) == 0)
14190                                                                 {
14191                                                                   /* 33222222222211111111110000000000
14192                                                                      10987654321098765432109876543210
14193                                                                      011001x1xx001101101xxxxxxxxxxxxx
14194                                                                      fsqrt.  */
14195                                                                   return 1471;
14196                                                                 }
14197                                                               else
14198                                                                 {
14199                                                                   if (((word >> 22) & 0x1) == 0)
14200                                                                     {
14201                                                                       /* 33222222222211111111110000000000
14202                                                                          10987654321098765432109876543210
14203                                                                          011001x1x0011101101xxxxxxxxxxxxx
14204                                                                          fcvtzu.  */
14205                                                                       return 1416;
14206                                                                     }
14207                                                                   else
14208                                                                     {
14209                                                                       if (((word >> 23) & 0x1) == 0)
14210                                                                         {
14211                                                                           /* 33222222222211111111110000000000
14212                                                                              10987654321098765432109876543210
14213                                                                              011001x101011101101xxxxxxxxxxxxx
14214                                                                              fcvtzu.  */
14215                                                                           return 1414;
14216                                                                         }
14217                                                                       else
14218                                                                         {
14219                                                                           /* 33222222222211111111110000000000
14220                                                                              10987654321098765432109876543210
14221                                                                              011001x111011101101xxxxxxxxxxxxx
14222                                                                              fcvtzu.  */
14223                                                                           return 1418;
14224                                                                         }
14225                                                                     }
14226                                                                 }
14227                                                             }
14228                                                         }
14229                                                     }
14230                                                   else
14231                                                     {
14232                                                       if (((word >> 18) & 0x1) == 0)
14233                                                         {
14234                                                           if (((word >> 19) & 0x1) == 0)
14235                                                             {
14236                                                               if (((word >> 20) & 0x1) == 0)
14237                                                                 {
14238                                                                   /* 33222222222211111111110000000000
14239                                                                      10987654321098765432109876543210
14240                                                                      011001x1xx000011101xxxxxxxxxxxxx
14241                                                                      frintz.  */
14242                                                                   return 1467;
14243                                                                 }
14244                                                               else
14245                                                                 {
14246                                                                   /* 33222222222211111111110000000000
14247                                                                      10987654321098765432109876543210
14248                                                                      011001x1xx010011101xxxxxxxxxxxxx
14249                                                                      ucvtf.  */
14250                                                                   return 1959;
14251                                                                 }
14252                                                             }
14253                                                           else
14254                                                             {
14255                                                               if (((word >> 20) & 0x1) == 0)
14256                                                                 {
14257                                                                   /* 33222222222211111111110000000000
14258                                                                      10987654321098765432109876543210
14259                                                                      011001x1xx001011101xxxxxxxxxxxxx
14260                                                                      fcvt.  */
14261                                                                   return 1405;
14262                                                                 }
14263                                                               else
14264                                                                 {
14265                                                                   /* 33222222222211111111110000000000
14266                                                                      10987654321098765432109876543210
14267                                                                      011001x1xx011011101xxxxxxxxxxxxx
14268                                                                      fcvtzu.  */
14269                                                                   return 1413;
14270                                                                 }
14271                                                             }
14272                                                         }
14273                                                       else
14274                                                         {
14275                                                           if (((word >> 19) & 0x1) == 0)
14276                                                             {
14277                                                               if (((word >> 20) & 0x1) == 0)
14278                                                                 {
14279                                                                   /* 33222222222211111111110000000000
14280                                                                      10987654321098765432109876543210
14281                                                                      011001x1xx000111101xxxxxxxxxxxxx
14282                                                                      frinti.  */
14283                                                                   return 1462;
14284                                                                 }
14285                                                               else
14286                                                                 {
14287                                                                   if (((word >> 23) & 0x1) == 0)
14288                                                                     {
14289                                                                       /* 33222222222211111111110000000000
14290                                                                          10987654321098765432109876543210
14291                                                                          011001x10x010111101xxxxxxxxxxxxx
14292                                                                          ucvtf.  */
14293                                                                       return 1963;
14294                                                                     }
14295                                                                   else
14296                                                                     {
14297                                                                       /* 33222222222211111111110000000000
14298                                                                          10987654321098765432109876543210
14299                                                                          011001x11x010111101xxxxxxxxxxxxx
14300                                                                          ucvtf.  */
14301                                                                       return 1965;
14302                                                                     }
14303                                                                 }
14304                                                             }
14305                                                           else
14306                                                             {
14307                                                               if (((word >> 23) & 0x1) == 0)
14308                                                                 {
14309                                                                   /* 33222222222211111111110000000000
14310                                                                      10987654321098765432109876543210
14311                                                                      011001x10x0x1111101xxxxxxxxxxxxx
14312                                                                      fcvtzu.  */
14313                                                                   return 1415;
14314                                                                 }
14315                                                               else
14316                                                                 {
14317                                                                   /* 33222222222211111111110000000000
14318                                                                      10987654321098765432109876543210
14319                                                                      011001x11x0x1111101xxxxxxxxxxxxx
14320                                                                      fcvtzu.  */
14321                                                                   return 1419;
14322                                                                 }
14323                                                             }
14324                                                         }
14325                                                     }
14326                                                 }
14327                                             }
14328                                           else
14329                                             {
14330                                               if (((word >> 22) & 0x1) == 0)
14331                                                 {
14332                                                   if (((word >> 23) & 0x1) == 0)
14333                                                     {
14334                                                       /* 33222222222211111111110000000000
14335                                                          10987654321098765432109876543210
14336                                                          111001x1000xxxxx101xxxxxxxxxxxxx
14337                                                          st1w.  */
14338                                                       return 1897;
14339                                                     }
14340                                                   else
14341                                                     {
14342                                                       /* 33222222222211111111110000000000
14343                                                          10987654321098765432109876543210
14344                                                          111001x1100xxxxx101xxxxxxxxxxxxx
14345                                                          st1d.  */
14346                                                       return 1876;
14347                                                     }
14348                                                 }
14349                                               else
14350                                                 {
14351                                                   if (((word >> 23) & 0x1) == 0)
14352                                                     {
14353                                                       /* 33222222222211111111110000000000
14354                                                          10987654321098765432109876543210
14355                                                          111001x1010xxxxx101xxxxxxxxxxxxx
14356                                                          st1w.  */
14357                                                       return 1904;
14358                                                     }
14359                                                   else
14360                                                     {
14361                                                       /* 33222222222211111111110000000000
14362                                                          10987654321098765432109876543210
14363                                                          111001x1110xxxxx101xxxxxxxxxxxxx
14364                                                          st1d.  */
14365                                                       return 1880;
14366                                                     }
14367                                                 }
14368                                             }
14369                                         }
14370                                       else
14371                                         {
14372                                           if (((word >> 31) & 0x1) == 0)
14373                                             {
14374                                               /* 33222222222211111111110000000000
14375                                                  10987654321098765432109876543210
14376                                                  011001x1xx0xxxxx111xxxxxxxxxxxxx
14377                                                  facgt.  */
14378                                               return 1378;
14379                                             }
14380                                           else
14381                                             {
14382                                               if (((word >> 20) & 0x1) == 0)
14383                                                 {
14384                                                   /* 33222222222211111111110000000000
14385                                                      10987654321098765432109876543210
14386                                                      111001x1xx00xxxx111xxxxxxxxxxxxx
14387                                                      st1w.  */
14388                                                   return 1905;
14389                                                 }
14390                                               else
14391                                                 {
14392                                                   if (((word >> 22) & 0x1) == 0)
14393                                                     {
14394                                                       if (((word >> 23) & 0x1) == 0)
14395                                                         {
14396                                                           /* 33222222222211111111110000000000
14397                                                              10987654321098765432109876543210
14398                                                              111001x10001xxxx111xxxxxxxxxxxxx
14399                                                              stnt1w.  */
14400                                                           return 1939;
14401                                                         }
14402                                                       else
14403                                                         {
14404                                                           /* 33222222222211111111110000000000
14405                                                              10987654321098765432109876543210
14406                                                              111001x11001xxxx111xxxxxxxxxxxxx
14407                                                              stnt1d.  */
14408                                                           return 1935;
14409                                                         }
14410                                                     }
14411                                                   else
14412                                                     {
14413                                                       if (((word >> 23) & 0x1) == 0)
14414                                                         {
14415                                                           /* 33222222222211111111110000000000
14416                                                              10987654321098765432109876543210
14417                                                              111001x10101xxxx111xxxxxxxxxxxxx
14418                                                              st3w.  */
14419                                                           return 1923;
14420                                                         }
14421                                                       else
14422                                                         {
14423                                                           /* 33222222222211111111110000000000
14424                                                              10987654321098765432109876543210
14425                                                              111001x11101xxxx111xxxxxxxxxxxxx
14426                                                              st3d.  */
14427                                                           return 1919;
14428                                                         }
14429                                                     }
14430                                                 }
14431                                             }
14432                                         }
14433                                     }
14434                                 }
14435                             }
14436                           else
14437                             {
14438                               if (((word >> 30) & 0x1) == 0)
14439                                 {
14440                                   if (((word >> 14) & 0x1) == 0)
14441                                     {
14442                                       if (((word >> 20) & 0x1) == 0)
14443                                         {
14444                                           if (((word >> 31) & 0x1) == 0)
14445                                             {
14446                                               if (((word >> 16) & 0x1) == 0)
14447                                                 {
14448                                                   if (((word >> 17) & 0x1) == 0)
14449                                                     {
14450                                                       if (((word >> 18) & 0x1) == 0)
14451                                                         {
14452                                                           if (((word >> 19) & 0x1) == 0)
14453                                                             {
14454                                                               /* 33222222222211111111110000000000
14455                                                                  10987654321098765432109876543210
14456                                                                  001001x1xx10000010xxxxxxxxxxxxxx
14457                                                                  cntp.  */
14458                                                               return 1347;
14459                                                             }
14460                                                           else
14461                                                             {
14462                                                               if (((word >> 10) & 0x1) == 0)
14463                                                                 {
14464                                                                   if (((word >> 11) & 0x1) == 0)
14465                                                                     {
14466                                                                       if (((word >> 12) & 0x1) == 0)
14467                                                                         {
14468                                                                           /* 33222222222211111111110000000000
14469                                                                              10987654321098765432109876543210
14470                                                                              001001x1xx10100010x000xxxxxxxxxx
14471                                                                              sqincp.  */
14472                                                                           return 1854;
14473                                                                         }
14474                                                                       else
14475                                                                         {
14476                                                                           /* 33222222222211111111110000000000
14477                                                                              10987654321098765432109876543210
14478                                                                              001001x1xx10100010x100xxxxxxxxxx
14479                                                                              wrffr.  */
14480                                                                           return 2027;
14481                                                                         }
14482                                                                     }
14483                                                                   else
14484                                                                     {
14485                                                                       /* 33222222222211111111110000000000
14486                                                                          10987654321098765432109876543210
14487                                                                          001001x1xx10100010xx10xxxxxxxxxx
14488                                                                          sqincp.  */
14489                                                                       return 1856;
14490                                                                     }
14491                                                                 }
14492                                                               else
14493                                                                 {
14494                                                                   /* 33222222222211111111110000000000
14495                                                                      10987654321098765432109876543210
14496                                                                      001001x1xx10100010xxx1xxxxxxxxxx
14497                                                                      sqincp.  */
14498                                                                   return 1855;
14499                                                                 }
14500                                                             }
14501                                                         }
14502                                                       else
14503                                                         {
14504                                                           if (((word >> 11) & 0x1) == 0)
14505                                                             {
14506                                                               if (((word >> 12) & 0x1) == 0)
14507                                                                 {
14508                                                                   /* 33222222222211111111110000000000
14509                                                                      10987654321098765432109876543210
14510                                                                      001001x1xx10x10010x00xxxxxxxxxxx
14511                                                                      incp.  */
14512                                                                   return 1485;
14513                                                                 }
14514                                                               else
14515                                                                 {
14516                                                                   /* 33222222222211111111110000000000
14517                                                                      10987654321098765432109876543210
14518                                                                      001001x1xx10x10010x10xxxxxxxxxxx
14519                                                                      setffr.  */
14520                                                                   return 1821;
14521                                                                 }
14522                                                             }
14523                                                           else
14524                                                             {
14525                                                               /* 33222222222211111111110000000000
14526                                                                  10987654321098765432109876543210
14527                                                                  001001x1xx10x10010xx1xxxxxxxxxxx
14528                                                                  incp.  */
14529                                                               return 1486;
14530                                                             }
14531                                                         }
14532                                                     }
14533                                                   else
14534                                                     {
14535                                                       if (((word >> 10) & 0x1) == 0)
14536                                                         {
14537                                                           if (((word >> 11) & 0x1) == 0)
14538                                                             {
14539                                                               /* 33222222222211111111110000000000
14540                                                                  10987654321098765432109876543210
14541                                                                  001001x1xx10xx1010xx00xxxxxxxxxx
14542                                                                  sqdecp.  */
14543                                                               return 1840;
14544                                                             }
14545                                                           else
14546                                                             {
14547                                                               /* 33222222222211111111110000000000
14548                                                                  10987654321098765432109876543210
14549                                                                  001001x1xx10xx1010xx10xxxxxxxxxx
14550                                                                  sqdecp.  */
14551                                                               return 1842;
14552                                                             }
14553                                                         }
14554                                                       else
14555                                                         {
14556                                                           /* 33222222222211111111110000000000
14557                                                              10987654321098765432109876543210
14558                                                              001001x1xx10xx1010xxx1xxxxxxxxxx
14559                                                              sqdecp.  */
14560                                                           return 1841;
14561                                                         }
14562                                                     }
14563                                                 }
14564                                               else
14565                                                 {
14566                                                   if (((word >> 10) & 0x1) == 0)
14567                                                     {
14568                                                       if (((word >> 11) & 0x1) == 0)
14569                                                         {
14570                                                           if (((word >> 17) & 0x1) == 0)
14571                                                             {
14572                                                               if (((word >> 18) & 0x1) == 0)
14573                                                                 {
14574                                                                   /* 33222222222211111111110000000000
14575                                                                      10987654321098765432109876543210
14576                                                                      001001x1xx10x00110xx00xxxxxxxxxx
14577                                                                      uqincp.  */
14578                                                                   return 2002;
14579                                                                 }
14580                                                               else
14581                                                                 {
14582                                                                   /* 33222222222211111111110000000000
14583                                                                      10987654321098765432109876543210
14584                                                                      001001x1xx10x10110xx00xxxxxxxxxx
14585                                                                      decp.  */
14586                                                                   return 1360;
14587                                                                 }
14588                                                             }
14589                                                           else
14590                                                             {
14591                                                               /* 33222222222211111111110000000000
14592                                                                  10987654321098765432109876543210
14593                                                                  001001x1xx10xx1110xx00xxxxxxxxxx
14594                                                                  uqdecp.  */
14595                                                               return 1988;
14596                                                             }
14597                                                         }
14598                                                       else
14599                                                         {
14600                                                           if (((word >> 17) & 0x1) == 0)
14601                                                             {
14602                                                               if (((word >> 18) & 0x1) == 0)
14603                                                                 {
14604                                                                   /* 33222222222211111111110000000000
14605                                                                      10987654321098765432109876543210
14606                                                                      001001x1xx10x00110xx10xxxxxxxxxx
14607                                                                      uqincp.  */
14608                                                                   return 2003;
14609                                                                 }
14610                                                               else
14611                                                                 {
14612                                                                   /* 33222222222211111111110000000000
14613                                                                      10987654321098765432109876543210
14614                                                                      001001x1xx10x10110xx10xxxxxxxxxx
14615                                                                      decp.  */
14616                                                                   return 1361;
14617                                                                 }
14618                                                             }
14619                                                           else
14620                                                             {
14621                                                               /* 33222222222211111111110000000000
14622                                                                  10987654321098765432109876543210
14623                                                                  001001x1xx10xx1110xx10xxxxxxxxxx
14624                                                                  uqdecp.  */
14625                                                               return 1989;
14626                                                             }
14627                                                         }
14628                                                     }
14629                                                   else
14630                                                     {
14631                                                       if (((word >> 17) & 0x1) == 0)
14632                                                         {
14633                                                           /* 33222222222211111111110000000000
14634                                                              10987654321098765432109876543210
14635                                                              001001x1xx10xx0110xxx1xxxxxxxxxx
14636                                                              uqincp.  */
14637                                                           return 2004;
14638                                                         }
14639                                                       else
14640                                                         {
14641                                                           /* 33222222222211111111110000000000
14642                                                              10987654321098765432109876543210
14643                                                              001001x1xx10xx1110xxx1xxxxxxxxxx
14644                                                              uqdecp.  */
14645                                                           return 1990;
14646                                                         }
14647                                                     }
14648                                                 }
14649                                             }
14650                                           else
14651                                             {
14652                                               if (((word >> 22) & 0x1) == 0)
14653                                                 {
14654                                                   if (((word >> 23) & 0x1) == 0)
14655                                                     {
14656                                                       /* 33222222222211111111110000000000
14657                                                          10987654321098765432109876543210
14658                                                          101001x10010xxxx10xxxxxxxxxxxxxx
14659                                                          ld1sh.  */
14660                                                       return 1578;
14661                                                     }
14662                                                   else
14663                                                     {
14664                                                       /* 33222222222211111111110000000000
14665                                                          10987654321098765432109876543210
14666                                                          101001x11010xxxx10xxxxxxxxxxxxxx
14667                                                          ld1sb.  */
14668                                                       return 1565;
14669                                                     }
14670                                                 }
14671                                               else
14672                                                 {
14673                                                   if (((word >> 23) & 0x1) == 0)
14674                                                     {
14675                                                       /* 33222222222211111111110000000000
14676                                                          10987654321098765432109876543210
14677                                                          101001x10110xxxx10xxxxxxxxxxxxxx
14678                                                          ld1w.  */
14679                                                       return 1597;
14680                                                     }
14681                                                   else
14682                                                     {
14683                                                       /* 33222222222211111111110000000000
14684                                                          10987654321098765432109876543210
14685                                                          101001x11110xxxx10xxxxxxxxxxxxxx
14686                                                          ld1d.  */
14687                                                       return 1517;
14688                                                     }
14689                                                 }
14690                                             }
14691                                         }
14692                                       else
14693                                         {
14694                                           if (((word >> 22) & 0x1) == 0)
14695                                             {
14696                                               if (((word >> 23) & 0x1) == 0)
14697                                                 {
14698                                                   /* 33222222222211111111110000000000
14699                                                      10987654321098765432109876543210
14700                                                      x01001x10011xxxx10xxxxxxxxxxxxxx
14701                                                      ldnf1sh.  */
14702                                                   return 1711;
14703                                                 }
14704                                               else
14705                                                 {
14706                                                   /* 33222222222211111111110000000000
14707                                                      10987654321098765432109876543210
14708                                                      x01001x11011xxxx10xxxxxxxxxxxxxx
14709                                                      ldnf1sb.  */
14710                                                   return 1708;
14711                                                 }
14712                                             }
14713                                           else
14714                                             {
14715                                               if (((word >> 23) & 0x1) == 0)
14716                                                 {
14717                                                   /* 33222222222211111111110000000000
14718                                                      10987654321098765432109876543210
14719                                                      x01001x10111xxxx10xxxxxxxxxxxxxx
14720                                                      ldnf1w.  */
14721                                                   return 1714;
14722                                                 }
14723                                               else
14724                                                 {
14725                                                   /* 33222222222211111111110000000000
14726                                                      10987654321098765432109876543210
14727                                                      x01001x11111xxxx10xxxxxxxxxxxxxx
14728                                                      ldnf1d.  */
14729                                                   return 1703;
14730                                                 }
14731                                             }
14732                                         }
14733                                     }
14734                                   else
14735                                     {
14736                                       if (((word >> 31) & 0x1) == 0)
14737                                         {
14738                                           if (((word >> 16) & 0x1) == 0)
14739                                             {
14740                                               if (((word >> 17) & 0x1) == 0)
14741                                                 {
14742                                                   if (((word >> 18) & 0x1) == 0)
14743                                                     {
14744                                                       if (((word >> 19) & 0x1) == 0)
14745                                                         {
14746                                                           if (((word >> 20) & 0x1) == 0)
14747                                                             {
14748                                                               /* 33222222222211111111110000000000
14749                                                                  10987654321098765432109876543210
14750                                                                  001001x1xx10000011xxxxxxxxxxxxxx
14751                                                                  add.  */
14752                                                               return 1274;
14753                                                             }
14754                                                           else
14755                                                             {
14756                                                               /* 33222222222211111111110000000000
14757                                                                  10987654321098765432109876543210
14758                                                                  001001x1xx11000011xxxxxxxxxxxxxx
14759                                                                  mul.  */
14760                                                               return 1743;
14761                                                             }
14762                                                         }
14763                                                       else
14764                                                         {
14765                                                           if (((word >> 20) & 0x1) == 0)
14766                                                             {
14767                                                               /* 33222222222211111111110000000000
14768                                                                  10987654321098765432109876543210
14769                                                                  001001x1xx10100011xxxxxxxxxxxxxx
14770                                                                  smax.  */
14771                                                               return 1822;
14772                                                             }
14773                                                           else
14774                                                             {
14775                                                               /* 33222222222211111111110000000000
14776                                                                  10987654321098765432109876543210
14777                                                                  001001x1xx11100011xxxxxxxxxxxxxx
14778                                                                  dup.  */
14779                                                               return 1366;
14780                                                             }
14781                                                         }
14782                                                     }
14783                                                   else
14784                                                     {
14785                                                       /* 33222222222211111111110000000000
14786                                                          10987654321098765432109876543210
14787                                                          001001x1xx1xx10011xxxxxxxxxxxxxx
14788                                                          sqadd.  */
14789                                                       return 1831;
14790                                                     }
14791                                                 }
14792                                               else
14793                                                 {
14794                                                   if (((word >> 18) & 0x1) == 0)
14795                                                     {
14796                                                       /* 33222222222211111111110000000000
14797                                                          10987654321098765432109876543210
14798                                                          001001x1xx1xx01011xxxxxxxxxxxxxx
14799                                                          smin.  */
14800                                                       return 1825;
14801                                                     }
14802                                                   else
14803                                                     {
14804                                                       /* 33222222222211111111110000000000
14805                                                          10987654321098765432109876543210
14806                                                          001001x1xx1xx11011xxxxxxxxxxxxxx
14807                                                          sqsub.  */
14808                                                       return 1861;
14809                                                     }
14810                                                 }
14811                                             }
14812                                           else
14813                                             {
14814                                               if (((word >> 17) & 0x1) == 0)
14815                                                 {
14816                                                   if (((word >> 18) & 0x1) == 0)
14817                                                     {
14818                                                       if (((word >> 19) & 0x1) == 0)
14819                                                         {
14820                                                           /* 33222222222211111111110000000000
14821                                                              10987654321098765432109876543210
14822                                                              001001x1xx1x000111xxxxxxxxxxxxxx
14823                                                              sub.  */
14824                                                           return 1943;
14825                                                         }
14826                                                       else
14827                                                         {
14828                                                           if (((word >> 20) & 0x1) == 0)
14829                                                             {
14830                                                               /* 33222222222211111111110000000000
14831                                                                  10987654321098765432109876543210
14832                                                                  001001x1xx10100111xxxxxxxxxxxxxx
14833                                                                  umax.  */
14834                                                               return 1971;
14835                                                             }
14836                                                           else
14837                                                             {
14838                                                               /* 33222222222211111111110000000000
14839                                                                  10987654321098765432109876543210
14840                                                                  001001x1xx11100111xxxxxxxxxxxxxx
14841                                                                  fdup.  */
14842                                                               return 1422;
14843                                                             }
14844                                                         }
14845                                                     }
14846                                                   else
14847                                                     {
14848                                                       /* 33222222222211111111110000000000
14849                                                          10987654321098765432109876543210
14850                                                          001001x1xx1xx10111xxxxxxxxxxxxxx
14851                                                          uqadd.  */
14852                                                       return 1979;
14853                                                     }
14854                                                 }
14855                                               else
14856                                                 {
14857                                                   if (((word >> 18) & 0x1) == 0)
14858                                                     {
14859                                                       if (((word >> 19) & 0x1) == 0)
14860                                                         {
14861                                                           /* 33222222222211111111110000000000
14862                                                              10987654321098765432109876543210
14863                                                              001001x1xx1x001111xxxxxxxxxxxxxx
14864                                                              subr.  */
14865                                                           return 1945;
14866                                                         }
14867                                                       else
14868                                                         {
14869                                                           /* 33222222222211111111110000000000
14870                                                              10987654321098765432109876543210
14871                                                              001001x1xx1x101111xxxxxxxxxxxxxx
14872                                                              umin.  */
14873                                                           return 1974;
14874                                                         }
14875                                                     }
14876                                                   else
14877                                                     {
14878                                                       /* 33222222222211111111110000000000
14879                                                          10987654321098765432109876543210
14880                                                          001001x1xx1xx11111xxxxxxxxxxxxxx
14881                                                          uqsub.  */
14882                                                       return 2009;
14883                                                     }
14884                                                 }
14885                                             }
14886                                         }
14887                                       else
14888                                         {
14889                                           if (((word >> 13) & 0x1) == 0)
14890                                             {
14891                                               if (((word >> 22) & 0x1) == 0)
14892                                                 {
14893                                                   if (((word >> 23) & 0x1) == 0)
14894                                                     {
14895                                                       /* 33222222222211111111110000000000
14896                                                          10987654321098765432109876543210
14897                                                          101001x1001xxxxx110xxxxxxxxxxxxx
14898                                                          ld2w.  */
14899                                                       return 1605;
14900                                                     }
14901                                                   else
14902                                                     {
14903                                                       /* 33222222222211111111110000000000
14904                                                          10987654321098765432109876543210
14905                                                          101001x1101xxxxx110xxxxxxxxxxxxx
14906                                                          ld2d.  */
14907                                                       return 1601;
14908                                                     }
14909                                                 }
14910                                               else
14911                                                 {
14912                                                   if (((word >> 23) & 0x1) == 0)
14913                                                     {
14914                                                       /* 33222222222211111111110000000000
14915                                                          10987654321098765432109876543210
14916                                                          101001x1011xxxxx110xxxxxxxxxxxxx
14917                                                          ld4w.  */
14918                                                       return 1621;
14919                                                     }
14920                                                   else
14921                                                     {
14922                                                       /* 33222222222211111111110000000000
14923                                                          10987654321098765432109876543210
14924                                                          101001x1111xxxxx110xxxxxxxxxxxxx
14925                                                          ld4d.  */
14926                                                       return 1617;
14927                                                     }
14928                                                 }
14929                                             }
14930                                           else
14931                                             {
14932                                               if (((word >> 22) & 0x1) == 0)
14933                                                 {
14934                                                   if (((word >> 23) & 0x1) == 0)
14935                                                     {
14936                                                       /* 33222222222211111111110000000000
14937                                                          10987654321098765432109876543210
14938                                                          101001x1001xxxxx111xxxxxxxxxxxxx
14939                                                          ld2w.  */
14940                                                       return 1606;
14941                                                     }
14942                                                   else
14943                                                     {
14944                                                       /* 33222222222211111111110000000000
14945                                                          10987654321098765432109876543210
14946                                                          101001x1101xxxxx111xxxxxxxxxxxxx
14947                                                          ld2d.  */
14948                                                       return 1602;
14949                                                     }
14950                                                 }
14951                                               else
14952                                                 {
14953                                                   if (((word >> 23) & 0x1) == 0)
14954                                                     {
14955                                                       /* 33222222222211111111110000000000
14956                                                          10987654321098765432109876543210
14957                                                          101001x1011xxxxx111xxxxxxxxxxxxx
14958                                                          ld4w.  */
14959                                                       return 1622;
14960                                                     }
14961                                                   else
14962                                                     {
14963                                                       /* 33222222222211111111110000000000
14964                                                          10987654321098765432109876543210
14965                                                          101001x1111xxxxx111xxxxxxxxxxxxx
14966                                                          ld4d.  */
14967                                                       return 1618;
14968                                                     }
14969                                                 }
14970                                             }
14971                                         }
14972                                     }
14973                                 }
14974                               else
14975                                 {
14976                                   if (((word >> 13) & 0x1) == 0)
14977                                     {
14978                                       if (((word >> 31) & 0x1) == 0)
14979                                         {
14980                                           if (((word >> 14) & 0x1) == 0)
14981                                             {
14982                                               /* 33222222222211111111110000000000
14983                                                  10987654321098765432109876543210
14984                                                  011001x1xx1xxxxx100xxxxxxxxxxxxx
14985                                                  fmad.  */
14986                                               return 1424;
14987                                             }
14988                                           else
14989                                             {
14990                                               /* 33222222222211111111110000000000
14991                                                  10987654321098765432109876543210
14992                                                  011001x1xx1xxxxx110xxxxxxxxxxxxx
14993                                                  fnmad.  */
14994                                               return 1454;
14995                                             }
14996                                         }
14997                                       else
14998                                         {
14999                                           if (((word >> 22) & 0x1) == 0)
15000                                             {
15001                                               if (((word >> 23) & 0x1) == 0)
15002                                                 {
15003                                                   /* 33222222222211111111110000000000
15004                                                      10987654321098765432109876543210
15005                                                      111001x1001xxxxx1x0xxxxxxxxxxxxx
15006                                                      st1w.  */
15007                                                   return 1898;
15008                                                 }
15009                                               else
15010                                                 {
15011                                                   /* 33222222222211111111110000000000
15012                                                      10987654321098765432109876543210
15013                                                      111001x1101xxxxx1x0xxxxxxxxxxxxx
15014                                                      st1d.  */
15015                                                   return 1877;
15016                                                 }
15017                                             }
15018                                           else
15019                                             {
15020                                               /* 33222222222211111111110000000000
15021                                                  10987654321098765432109876543210
15022                                                  111001x1x11xxxxx1x0xxxxxxxxxxxxx
15023                                                  st1w.  */
15024                                               return 1903;
15025                                             }
15026                                         }
15027                                     }
15028                                   else
15029                                     {
15030                                       if (((word >> 14) & 0x1) == 0)
15031                                         {
15032                                           if (((word >> 31) & 0x1) == 0)
15033                                             {
15034                                               /* 33222222222211111111110000000000
15035                                                  10987654321098765432109876543210
15036                                                  011001x1xx1xxxxx101xxxxxxxxxxxxx
15037                                                  fmsb.  */
15038                                               return 1445;
15039                                             }
15040                                           else
15041                                             {
15042                                               if (((word >> 22) & 0x1) == 0)
15043                                                 {
15044                                                   if (((word >> 23) & 0x1) == 0)
15045                                                     {
15046                                                       /* 33222222222211111111110000000000
15047                                                          10987654321098765432109876543210
15048                                                          111001x1001xxxxx101xxxxxxxxxxxxx
15049                                                          st1w.  */
15050                                                       return 1899;
15051                                                     }
15052                                                   else
15053                                                     {
15054                                                       /* 33222222222211111111110000000000
15055                                                          10987654321098765432109876543210
15056                                                          111001x1101xxxxx101xxxxxxxxxxxxx
15057                                                          st1d.  */
15058                                                       return 1878;
15059                                                     }
15060                                                 }
15061                                               else
15062                                                 {
15063                                                   /* 33222222222211111111110000000000
15064                                                      10987654321098765432109876543210
15065                                                      111001x1x11xxxxx101xxxxxxxxxxxxx
15066                                                      st1w.  */
15067                                                   return 1906;
15068                                                 }
15069                                             }
15070                                         }
15071                                       else
15072                                         {
15073                                           if (((word >> 31) & 0x1) == 0)
15074                                             {
15075                                               /* 33222222222211111111110000000000
15076                                                  10987654321098765432109876543210
15077                                                  011001x1xx1xxxxx111xxxxxxxxxxxxx
15078                                                  fnmsb.  */
15079                                               return 1457;
15080                                             }
15081                                           else
15082                                             {
15083                                               if (((word >> 20) & 0x1) == 0)
15084                                                 {
15085                                                   if (((word >> 23) & 0x1) == 0)
15086                                                     {
15087                                                       /* 33222222222211111111110000000000
15088                                                          10987654321098765432109876543210
15089                                                          111001x10x10xxxx111xxxxxxxxxxxxx
15090                                                          st1w.  */
15091                                                       return 1907;
15092                                                     }
15093                                                   else
15094                                                     {
15095                                                       /* 33222222222211111111110000000000
15096                                                          10987654321098765432109876543210
15097                                                          111001x11x10xxxx111xxxxxxxxxxxxx
15098                                                          st1d.  */
15099                                                       return 1881;
15100                                                     }
15101                                                 }
15102                                               else
15103                                                 {
15104                                                   if (((word >> 22) & 0x1) == 0)
15105                                                     {
15106                                                       if (((word >> 23) & 0x1) == 0)
15107                                                         {
15108                                                           /* 33222222222211111111110000000000
15109                                                              10987654321098765432109876543210
15110                                                              111001x10011xxxx111xxxxxxxxxxxxx
15111                                                              st2w.  */
15112                                                           return 1915;
15113                                                         }
15114                                                       else
15115                                                         {
15116                                                           /* 33222222222211111111110000000000
15117                                                              10987654321098765432109876543210
15118                                                              111001x11011xxxx111xxxxxxxxxxxxx
15119                                                              st2d.  */
15120                                                           return 1911;
15121                                                         }
15122                                                     }
15123                                                   else
15124                                                     {
15125                                                       if (((word >> 23) & 0x1) == 0)
15126                                                         {
15127                                                           /* 33222222222211111111110000000000
15128                                                              10987654321098765432109876543210
15129                                                              111001x10111xxxx111xxxxxxxxxxxxx
15130                                                              st4w.  */
15131                                                           return 1931;
15132                                                         }
15133                                                       else
15134                                                         {
15135                                                           /* 33222222222211111111110000000000
15136                                                              10987654321098765432109876543210
15137                                                              111001x11111xxxx111xxxxxxxxxxxxx
15138                                                              st4d.  */
15139                                                           return 1927;
15140                                                         }
15141                                                     }
15142                                                 }
15143                                             }
15144                                         }
15145                                     }
15146                                 }
15147                             }
15148                         }
15149                     }
15150                 }
15151             }
15152           else
15153             {
15154               if (((word >> 29) & 0x1) == 0)
15155                 {
15156                   if (((word >> 30) & 0x1) == 0)
15157                     {
15158                       if (((word >> 31) & 0x1) == 0)
15159                         {
15160                           /* 33222222222211111111110000000000
15161                              10987654321098765432109876543210
15162                              000101xxxxxxxxxxxxxxxxxxxxxxxxxx
15163                              b.  */
15164                           return 636;
15165                         }
15166                       else
15167                         {
15168                           /* 33222222222211111111110000000000
15169                              10987654321098765432109876543210
15170                              100101xxxxxxxxxxxxxxxxxxxxxxxxxx
15171                              bl.  */
15172                           return 637;
15173                         }
15174                     }
15175                   else
15176                     {
15177                       if (((word >> 24) & 0x1) == 0)
15178                         {
15179                           if (((word >> 4) & 0x1) == 0)
15180                             {
15181                               if (((word >> 25) & 0x1) == 0)
15182                                 {
15183                                   if (((word >> 31) & 0x1) == 0)
15184                                     {
15185                                       /* 33222222222211111111110000000000
15186                                          10987654321098765432109876543210
15187                                          01010100xxxxxxxxxxxxxxxxxxx0xxxx
15188                                          b.c.  */
15189                                       return 657;
15190                                     }
15191                                   else
15192                                     {
15193                                       if (((word >> 0) & 0x1) == 0)
15194                                         {
15195                                           if (((word >> 1) & 0x1) == 0)
15196                                             {
15197                                               if (((word >> 21) & 0x1) == 0)
15198                                                 {
15199                                                   /* 33222222222211111111110000000000
15200                                                      10987654321098765432109876543210
15201                                                      11010100xx0xxxxxxxxxxxxxxxx0xx00
15202                                                      hlt.  */
15203                                                   return 753;
15204                                                 }
15205                                               else
15206                                                 {
15207                                                   if (((word >> 22) & 0x1) == 0)
15208                                                     {
15209                                                       /* 33222222222211111111110000000000
15210                                                          10987654321098765432109876543210
15211                                                          11010100x01xxxxxxxxxxxxxxxx0xx00
15212                                                          brk.  */
15213                                                       return 752;
15214                                                     }
15215                                                   else
15216                                                     {
15217                                                       /* 33222222222211111111110000000000
15218                                                          10987654321098765432109876543210
15219                                                          11010100x11xxxxxxxxxxxxxxxx0xx00
15220                                                          tcancel.  */
15221                                                       return 1191;
15222                                                     }
15223                                                 }
15224                                             }
15225                                           else
15226                                             {
15227                                               if (((word >> 21) & 0x1) == 0)
15228                                                 {
15229                                                   /* 33222222222211111111110000000000
15230                                                      10987654321098765432109876543210
15231                                                      11010100xx0xxxxxxxxxxxxxxxx0xx10
15232                                                      hvc.  */
15233                                                   return 750;
15234                                                 }
15235                                               else
15236                                                 {
15237                                                   /* 33222222222211111111110000000000
15238                                                      10987654321098765432109876543210
15239                                                      11010100xx1xxxxxxxxxxxxxxxx0xx10
15240                                                      dcps2.  */
15241                                                   return 755;
15242                                                 }
15243                                             }
15244                                         }
15245                                       else
15246                                         {
15247                                           if (((word >> 1) & 0x1) == 0)
15248                                             {
15249                                               if (((word >> 21) & 0x1) == 0)
15250                                                 {
15251                                                   /* 33222222222211111111110000000000
15252                                                      10987654321098765432109876543210
15253                                                      11010100xx0xxxxxxxxxxxxxxxx0xx01
15254                                                      svc.  */
15255                                                   return 749;
15256                                                 }
15257                                               else
15258                                                 {
15259                                                   /* 33222222222211111111110000000000
15260                                                      10987654321098765432109876543210
15261                                                      11010100xx1xxxxxxxxxxxxxxxx0xx01
15262                                                      dcps1.  */
15263                                                   return 754;
15264                                                 }
15265                                             }
15266                                           else
15267                                             {
15268                                               if (((word >> 21) & 0x1) == 0)
15269                                                 {
15270                                                   /* 33222222222211111111110000000000
15271                                                      10987654321098765432109876543210
15272                                                      11010100xx0xxxxxxxxxxxxxxxx0xx11
15273                                                      smc.  */
15274                                                   return 751;
15275                                                 }
15276                                               else
15277                                                 {
15278                                                   /* 33222222222211111111110000000000
15279                                                      10987654321098765432109876543210
15280                                                      11010100xx1xxxxxxxxxxxxxxxx0xx11
15281                                                      dcps3.  */
15282                                                   return 756;
15283                                                 }
15284                                             }
15285                                         }
15286                                     }
15287                                 }
15288                               else
15289                                 {
15290                                   if (((word >> 21) & 0x1) == 0)
15291                                     {
15292                                       if (((word >> 22) & 0x1) == 0)
15293                                         {
15294                                           if (((word >> 23) & 0x1) == 0)
15295                                             {
15296                                               /* 33222222222211111111110000000000
15297                                                  10987654321098765432109876543210
15298                                                  x1010110000xxxxxxxxxxxxxxxx0xxxx
15299                                                  br.  */
15300                                               return 638;
15301                                             }
15302                                           else
15303                                             {
15304                                               /* 33222222222211111111110000000000
15305                                                  10987654321098765432109876543210
15306                                                  x1010110100xxxxxxxxxxxxxxxx0xxxx
15307                                                  eret.  */
15308                                               return 641;
15309                                             }
15310                                         }
15311                                       else
15312                                         {
15313                                           /* 33222222222211111111110000000000
15314                                              10987654321098765432109876543210
15315                                              x1010110x10xxxxxxxxxxxxxxxx0xxxx
15316                                              ret.  */
15317                                           return 640;
15318                                         }
15319                                     }
15320                                   else
15321                                     {
15322                                       if (((word >> 23) & 0x1) == 0)
15323                                         {
15324                                           /* 33222222222211111111110000000000
15325                                              10987654321098765432109876543210
15326                                              x10101100x1xxxxxxxxxxxxxxxx0xxxx
15327                                              blr.  */
15328                                           return 639;
15329                                         }
15330                                       else
15331                                         {
15332                                           /* 33222222222211111111110000000000
15333                                              10987654321098765432109876543210
15334                                              x10101101x1xxxxxxxxxxxxxxxx0xxxx
15335                                              drps.  */
15336                                           return 642;
15337                                         }
15338                                     }
15339                                 }
15340                             }
15341                           else
15342                             {
15343                               if (((word >> 10) & 0x1) == 0)
15344                                 {
15345                                   if (((word >> 21) & 0x1) == 0)
15346                                     {
15347                                       if (((word >> 22) & 0x1) == 0)
15348                                         {
15349                                           if (((word >> 23) & 0x1) == 0)
15350                                             {
15351                                               /* 33222222222211111111110000000000
15352                                                  10987654321098765432109876543210
15353                                                  x10101x0000xxxxxxxxxx0xxxxx1xxxx
15354                                                  braaz.  */
15355                                               return 647;
15356                                             }
15357                                           else
15358                                             {
15359                                               /* 33222222222211111111110000000000
15360                                                  10987654321098765432109876543210
15361                                                  x10101x0100xxxxxxxxxx0xxxxx1xxxx
15362                                                  eretaa.  */
15363                                               return 653;
15364                                             }
15365                                         }
15366                                       else
15367                                         {
15368                                           /* 33222222222211111111110000000000
15369                                              10987654321098765432109876543210
15370                                              x10101x0x10xxxxxxxxxx0xxxxx1xxxx
15371                                              retaa.  */
15372                                           return 651;
15373                                         }
15374                                     }
15375                                   else
15376                                     {
15377                                       /* 33222222222211111111110000000000
15378                                          10987654321098765432109876543210
15379                                          x10101x0xx1xxxxxxxxxx0xxxxx1xxxx
15380                                          blraaz.  */
15381                                       return 649;
15382                                     }
15383                                 }
15384                               else
15385                                 {
15386                                   if (((word >> 21) & 0x1) == 0)
15387                                     {
15388                                       if (((word >> 22) & 0x1) == 0)
15389                                         {
15390                                           if (((word >> 23) & 0x1) == 0)
15391                                             {
15392                                               /* 33222222222211111111110000000000
15393                                                  10987654321098765432109876543210
15394                                                  x10101x0000xxxxxxxxxx1xxxxx1xxxx
15395                                                  brabz.  */
15396                                               return 648;
15397                                             }
15398                                           else
15399                                             {
15400                                               /* 33222222222211111111110000000000
15401                                                  10987654321098765432109876543210
15402                                                  x10101x0100xxxxxxxxxx1xxxxx1xxxx
15403                                                  eretab.  */
15404                                               return 654;
15405                                             }
15406                                         }
15407                                       else
15408                                         {
15409                                           /* 33222222222211111111110000000000
15410                                              10987654321098765432109876543210
15411                                              x10101x0x10xxxxxxxxxx1xxxxx1xxxx
15412                                              retab.  */
15413                                           return 652;
15414                                         }
15415                                     }
15416                                   else
15417                                     {
15418                                       /* 33222222222211111111110000000000
15419                                          10987654321098765432109876543210
15420                                          x10101x0xx1xxxxxxxxxx1xxxxx1xxxx
15421                                          blrabz.  */
15422                                       return 650;
15423                                     }
15424                                 }
15425                             }
15426                         }
15427                       else
15428                         {
15429                           if (((word >> 21) & 0x1) == 0)
15430                             {
15431                               if (((word >> 25) & 0x1) == 0)
15432                                 {
15433                                   /* 33222222222211111111110000000000
15434                                      10987654321098765432109876543210
15435                                      x1010101xx0xxxxxxxxxxxxxxxxxxxxx
15436                                      xaflag.  */
15437                                   return 810;
15438                                 }
15439                               else
15440                                 {
15441                                   if (((word >> 10) & 0x1) == 0)
15442                                     {
15443                                       /* 33222222222211111111110000000000
15444                                          10987654321098765432109876543210
15445                                          x1010111xx0xxxxxxxxxx0xxxxxxxxxx
15446                                          braa.  */
15447                                       return 643;
15448                                     }
15449                                   else
15450                                     {
15451                                       /* 33222222222211111111110000000000
15452                                          10987654321098765432109876543210
15453                                          x1010111xx0xxxxxxxxxx1xxxxxxxxxx
15454                                          brab.  */
15455                                       return 644;
15456                                     }
15457                                 }
15458                             }
15459                           else
15460                             {
15461                               if (((word >> 25) & 0x1) == 0)
15462                                 {
15463                                   /* 33222222222211111111110000000000
15464                                      10987654321098765432109876543210
15465                                      x1010101xx1xxxxxxxxxxxxxxxxxxxxx
15466                                      tstart.  */
15467                                   return 1188;
15468                                 }
15469                               else
15470                                 {
15471                                   if (((word >> 10) & 0x1) == 0)
15472                                     {
15473                                       /* 33222222222211111111110000000000
15474                                          10987654321098765432109876543210
15475                                          x1010111xx1xxxxxxxxxx0xxxxxxxxxx
15476                                          blraa.  */
15477                                       return 645;
15478                                     }
15479                                   else
15480                                     {
15481                                       /* 33222222222211111111110000000000
15482                                          10987654321098765432109876543210
15483                                          x1010111xx1xxxxxxxxxx1xxxxxxxxxx
15484                                          blrab.  */
15485                                       return 646;
15486                                     }
15487                                 }
15488                             }
15489                         }
15490                     }
15491                 }
15492               else
15493                 {
15494                   if (((word >> 24) & 0x1) == 0)
15495                     {
15496                       if (((word >> 25) & 0x1) == 0)
15497                         {
15498                           /* 33222222222211111111110000000000
15499                              10987654321098765432109876543210
15500                              xx110100xxxxxxxxxxxxxxxxxxxxxxxx
15501                              cbz.  */
15502                           return 655;
15503                         }
15504                       else
15505                         {
15506                           /* 33222222222211111111110000000000
15507                              10987654321098765432109876543210
15508                              xx110110xxxxxxxxxxxxxxxxxxxxxxxx
15509                              tbz.  */
15510                           return 1235;
15511                         }
15512                     }
15513                   else
15514                     {
15515                       if (((word >> 25) & 0x1) == 0)
15516                         {
15517                           /* 33222222222211111111110000000000
15518                              10987654321098765432109876543210
15519                              xx110101xxxxxxxxxxxxxxxxxxxxxxxx
15520                              cbnz.  */
15521                           return 656;
15522                         }
15523                       else
15524                         {
15525                           /* 33222222222211111111110000000000
15526                              10987654321098765432109876543210
15527                              xx110111xxxxxxxxxxxxxxxxxxxxxxxx
15528                              tbnz.  */
15529                           return 1236;
15530                         }
15531                     }
15532                 }
15533             }
15534         }
15535       else
15536         {
15537           if (((word >> 25) & 0x1) == 0)
15538             {
15539               if (((word >> 28) & 0x1) == 0)
15540                 {
15541                   if (((word >> 22) & 0x1) == 0)
15542                     {
15543                       if (((word >> 23) & 0x1) == 0)
15544                         {
15545                           if (((word >> 24) & 0x1) == 0)
15546                             {
15547                               if (((word >> 29) & 0x1) == 0)
15548                                 {
15549                                   /* 33222222222211111111110000000000
15550                                      10987654321098765432109876543210
15551                                      xx00110000xxxxxxxxxxxxxxxxxxxxxx
15552                                      st4.  */
15553                                   return 440;
15554                                 }
15555                               else
15556                                 {
15557                                   /* 33222222222211111111110000000000
15558                                      10987654321098765432109876543210
15559                                      xx10110000xxxxxxxxxxxxxxxxxxxxxx
15560                                      stnp.  */
15561                                   return 972;
15562                                 }
15563                             }
15564                           else
15565                             {
15566                               if (((word >> 29) & 0x1) == 0)
15567                                 {
15568                                   if (((word >> 13) & 0x1) == 0)
15569                                     {
15570                                       if (((word >> 21) & 0x1) == 0)
15571                                         {
15572                                           /* 33222222222211111111110000000000
15573                                              10987654321098765432109876543210
15574                                              xx001101000xxxxxxx0xxxxxxxxxxxxx
15575                                              st1.  */
15576                                           return 456;
15577                                         }
15578                                       else
15579                                         {
15580                                           /* 33222222222211111111110000000000
15581                                              10987654321098765432109876543210
15582                                              xx001101001xxxxxxx0xxxxxxxxxxxxx
15583                                              st2.  */
15584                                           return 458;
15585                                         }
15586                                     }
15587                                   else
15588                                     {
15589                                       if (((word >> 21) & 0x1) == 0)
15590                                         {
15591                                           /* 33222222222211111111110000000000
15592                                              10987654321098765432109876543210
15593                                              xx001101000xxxxxxx1xxxxxxxxxxxxx
15594                                              st3.  */
15595                                           return 457;
15596                                         }
15597                                       else
15598                                         {
15599                                           /* 33222222222211111111110000000000
15600                                              10987654321098765432109876543210
15601                                              xx001101001xxxxxxx1xxxxxxxxxxxxx
15602                                              st4.  */
15603                                           return 459;
15604                                         }
15605                                     }
15606                                 }
15607                               else
15608                                 {
15609                                   /* 33222222222211111111110000000000
15610                                      10987654321098765432109876543210
15611                                      xx10110100xxxxxxxxxxxxxxxxxxxxxx
15612                                      stp.  */
15613                                   return 976;
15614                                 }
15615                             }
15616                         }
15617                       else
15618                         {
15619                           if (((word >> 29) & 0x1) == 0)
15620                             {
15621                               if (((word >> 21) & 0x1) == 0)
15622                                 {
15623                                   if (((word >> 24) & 0x1) == 0)
15624                                     {
15625                                       /* 33222222222211111111110000000000
15626                                          10987654321098765432109876543210
15627                                          xx001100100xxxxxxxxxxxxxxxxxxxxx
15628                                          st4.  */
15629                                       return 448;
15630                                     }
15631                                   else
15632                                     {
15633                                       if (((word >> 13) & 0x1) == 0)
15634                                         {
15635                                           /* 33222222222211111111110000000000
15636                                              10987654321098765432109876543210
15637                                              xx001101100xxxxxxx0xxxxxxxxxxxxx
15638                                              st1.  */
15639                                           return 468;
15640                                         }
15641                                       else
15642                                         {
15643                                           /* 33222222222211111111110000000000
15644                                              10987654321098765432109876543210
15645                                              xx001101100xxxxxxx1xxxxxxxxxxxxx
15646                                              st3.  */
15647                                           return 469;
15648                                         }
15649                                     }
15650                                 }
15651                               else
15652                                 {
15653                                   if (((word >> 13) & 0x1) == 0)
15654                                     {
15655                                       /* 33222222222211111111110000000000
15656                                          10987654321098765432109876543210
15657                                          xx00110x101xxxxxxx0xxxxxxxxxxxxx
15658                                          st2.  */
15659                                       return 470;
15660                                     }
15661                                   else
15662                                     {
15663                                       /* 33222222222211111111110000000000
15664                                          10987654321098765432109876543210
15665                                          xx00110x101xxxxxxx1xxxxxxxxxxxxx
15666                                          st4.  */
15667                                       return 471;
15668                                     }
15669                                 }
15670                             }
15671                           else
15672                             {
15673                               /* 33222222222211111111110000000000
15674                                  10987654321098765432109876543210
15675                                  xx10110x10xxxxxxxxxxxxxxxxxxxxxx
15676                                  stp.  */
15677                               return 982;
15678                             }
15679                         }
15680                     }
15681                   else
15682                     {
15683                       if (((word >> 23) & 0x1) == 0)
15684                         {
15685                           if (((word >> 24) & 0x1) == 0)
15686                             {
15687                               if (((word >> 29) & 0x1) == 0)
15688                                 {
15689                                   /* 33222222222211111111110000000000
15690                                      10987654321098765432109876543210
15691                                      xx00110001xxxxxxxxxxxxxxxxxxxxxx
15692                                      ld4.  */
15693                                   return 444;
15694                                 }
15695                               else
15696                                 {
15697                                   /* 33222222222211111111110000000000
15698                                      10987654321098765432109876543210
15699                                      xx10110001xxxxxxxxxxxxxxxxxxxxxx
15700                                      ldnp.  */
15701                                   return 973;
15702                                 }
15703                             }
15704                           else
15705                             {
15706                               if (((word >> 29) & 0x1) == 0)
15707                                 {
15708                                   if (((word >> 13) & 0x1) == 0)
15709                                     {
15710                                       if (((word >> 21) & 0x1) == 0)
15711                                         {
15712                                           /* 33222222222211111111110000000000
15713                                              10987654321098765432109876543210
15714                                              xx001101010xxxxxxx0xxxxxxxxxxxxx
15715                                              ld1.  */
15716                                           return 460;
15717                                         }
15718                                       else
15719                                         {
15720                                           /* 33222222222211111111110000000000
15721                                              10987654321098765432109876543210
15722                                              xx001101011xxxxxxx0xxxxxxxxxxxxx
15723                                              ld2.  */
15724                                           return 464;
15725                                         }
15726                                     }
15727                                   else
15728                                     {
15729                                       if (((word >> 21) & 0x1) == 0)
15730                                         {
15731                                           /* 33222222222211111111110000000000
15732                                              10987654321098765432109876543210
15733                                              xx001101010xxxxxxx1xxxxxxxxxxxxx
15734                                              ld3.  */
15735                                           return 461;
15736                                         }
15737                                       else
15738                                         {
15739                                           /* 33222222222211111111110000000000
15740                                              10987654321098765432109876543210
15741                                              xx001101011xxxxxxx1xxxxxxxxxxxxx
15742                                              ld4.  */
15743                                           return 465;
15744                                         }
15745                                     }
15746                                 }
15747                               else
15748                                 {
15749                                   /* 33222222222211111111110000000000
15750                                      10987654321098765432109876543210
15751                                      xx10110101xxxxxxxxxxxxxxxxxxxxxx
15752                                      ldp.  */
15753                                   return 977;
15754                                 }
15755                             }
15756                         }
15757                       else
15758                         {
15759                           if (((word >> 29) & 0x1) == 0)
15760                             {
15761                               if (((word >> 21) & 0x1) == 0)
15762                                 {
15763                                   if (((word >> 24) & 0x1) == 0)
15764                                     {
15765                                       /* 33222222222211111111110000000000
15766                                          10987654321098765432109876543210
15767                                          xx001100110xxxxxxxxxxxxxxxxxxxxx
15768                                          ld4.  */
15769                                       return 452;
15770                                     }
15771                                   else
15772                                     {
15773                                       if (((word >> 13) & 0x1) == 0)
15774                                         {
15775                                           /* 33222222222211111111110000000000
15776                                              10987654321098765432109876543210
15777                                              xx001101110xxxxxxx0xxxxxxxxxxxxx
15778                                              ld1.  */
15779                                           return 472;
15780                                         }
15781                                       else
15782                                         {
15783                                           /* 33222222222211111111110000000000
15784                                              10987654321098765432109876543210
15785                                              xx001101110xxxxxxx1xxxxxxxxxxxxx
15786                                              ld3.  */
15787                                           return 473;
15788                                         }
15789                                     }
15790                                 }
15791                               else
15792                                 {
15793                                   if (((word >> 13) & 0x1) == 0)
15794                                     {
15795                                       /* 33222222222211111111110000000000
15796                                          10987654321098765432109876543210
15797                                          xx00110x111xxxxxxx0xxxxxxxxxxxxx
15798                                          ld2.  */
15799                                       return 476;
15800                                     }
15801                                   else
15802                                     {
15803                                       /* 33222222222211111111110000000000
15804                                          10987654321098765432109876543210
15805                                          xx00110x111xxxxxxx1xxxxxxxxxxxxx
15806                                          ld4.  */
15807                                       return 477;
15808                                     }
15809                                 }
15810                             }
15811                           else
15812                             {
15813                               /* 33222222222211111111110000000000
15814                                  10987654321098765432109876543210
15815                                  xx10110x11xxxxxxxxxxxxxxxxxxxxxx
15816                                  ldp.  */
15817                               return 983;
15818                             }
15819                         }
15820                     }
15821                 }
15822               else
15823                 {
15824                   if (((word >> 24) & 0x1) == 0)
15825                     {
15826                       if (((word >> 29) & 0x1) == 0)
15827                         {
15828                           /* 33222222222211111111110000000000
15829                              10987654321098765432109876543210
15830                              xx011100xxxxxxxxxxxxxxxxxxxxxxxx
15831                              ldr.  */
15832                           return 987;
15833                         }
15834                       else
15835                         {
15836                           if (((word >> 10) & 0x1) == 0)
15837                             {
15838                               if (((word >> 11) & 0x1) == 0)
15839                                 {
15840                                   if (((word >> 22) & 0x1) == 0)
15841                                     {
15842                                       /* 33222222222211111111110000000000
15843                                          10987654321098765432109876543210
15844                                          xx111100x0xxxxxxxxxx00xxxxxxxxxx
15845                                          stur.  */
15846                                       return 924;
15847                                     }
15848                                   else
15849                                     {
15850                                       /* 33222222222211111111110000000000
15851                                          10987654321098765432109876543210
15852                                          xx111100x1xxxxxxxxxx00xxxxxxxxxx
15853                                          ldur.  */
15854                                       return 925;
15855                                     }
15856                                 }
15857                               else
15858                                 {
15859                                   if (((word >> 22) & 0x1) == 0)
15860                                     {
15861                                       /* 33222222222211111111110000000000
15862                                          10987654321098765432109876543210
15863                                          xx111100x0xxxxxxxxxx10xxxxxxxxxx
15864                                          str.  */
15865                                       return 903;
15866                                     }
15867                                   else
15868                                     {
15869                                       /* 33222222222211111111110000000000
15870                                          10987654321098765432109876543210
15871                                          xx111100x1xxxxxxxxxx10xxxxxxxxxx
15872                                          ldr.  */
15873                                       return 904;
15874                                     }
15875                                 }
15876                             }
15877                           else
15878                             {
15879                               if (((word >> 22) & 0x1) == 0)
15880                                 {
15881                                   /* 33222222222211111111110000000000
15882                                      10987654321098765432109876543210
15883                                      xx111100x0xxxxxxxxxxx1xxxxxxxxxx
15884                                      str.  */
15885                                   return 872;
15886                                 }
15887                               else
15888                                 {
15889                                   /* 33222222222211111111110000000000
15890                                      10987654321098765432109876543210
15891                                      xx111100x1xxxxxxxxxxx1xxxxxxxxxx
15892                                      ldr.  */
15893                                   return 873;
15894                                 }
15895                             }
15896                         }
15897                     }
15898                   else
15899                     {
15900                       if (((word >> 22) & 0x1) == 0)
15901                         {
15902                           /* 33222222222211111111110000000000
15903                              10987654321098765432109876543210
15904                              xxx11101x0xxxxxxxxxxxxxxxxxxxxxx
15905                              str.  */
15906                           return 891;
15907                         }
15908                       else
15909                         {
15910                           /* 33222222222211111111110000000000
15911                              10987654321098765432109876543210
15912                              xxx11101x1xxxxxxxxxxxxxxxxxxxxxx
15913                              ldr.  */
15914                           return 892;
15915                         }
15916                     }
15917                 }
15918             }
15919           else
15920             {
15921               if (((word >> 24) & 0x1) == 0)
15922                 {
15923                   if (((word >> 21) & 0x1) == 0)
15924                     {
15925                       if (((word >> 28) & 0x1) == 0)
15926                         {
15927                           if (((word >> 29) & 0x1) == 0)
15928                             {
15929                               if (((word >> 31) & 0x1) == 0)
15930                                 {
15931                                   if (((word >> 10) & 0x1) == 0)
15932                                     {
15933                                       if (((word >> 11) & 0x1) == 0)
15934                                         {
15935                                           if (((word >> 12) & 0x1) == 0)
15936                                             {
15937                                               /* 33222222222211111111110000000000
15938                                                  10987654321098765432109876543210
15939                                                  0x001110xx0xxxxxxxx000xxxxxxxxxx
15940                                                  tbl.  */
15941                                               return 420;
15942                                             }
15943                                           else
15944                                             {
15945                                               /* 33222222222211111111110000000000
15946                                                  10987654321098765432109876543210
15947                                                  0x001110xx0xxxxxxxx100xxxxxxxxxx
15948                                                  tbx.  */
15949                                               return 421;
15950                                             }
15951                                         }
15952                                       else
15953                                         {
15954                                           if (((word >> 12) & 0x1) == 0)
15955                                             {
15956                                               if (((word >> 14) & 0x1) == 0)
15957                                                 {
15958                                                   /* 33222222222211111111110000000000
15959                                                      10987654321098765432109876543210
15960                                                      0x001110xx0xxxxxx0x010xxxxxxxxxx
15961                                                      trn1.  */
15962                                                   return 263;
15963                                                 }
15964                                               else
15965                                                 {
15966                                                   /* 33222222222211111111110000000000
15967                                                      10987654321098765432109876543210
15968                                                      0x001110xx0xxxxxx1x010xxxxxxxxxx
15969                                                      trn2.  */
15970                                                   return 266;
15971                                                 }
15972                                             }
15973                                           else
15974                                             {
15975                                               if (((word >> 13) & 0x1) == 0)
15976                                                 {
15977                                                   if (((word >> 14) & 0x1) == 0)
15978                                                     {
15979                                                       /* 33222222222211111111110000000000
15980                                                          10987654321098765432109876543210
15981                                                          0x001110xx0xxxxxx00110xxxxxxxxxx
15982                                                          uzp1.  */
15983                                                       return 262;
15984                                                     }
15985                                                   else
15986                                                     {
15987                                                       /* 33222222222211111111110000000000
15988                                                          10987654321098765432109876543210
15989                                                          0x001110xx0xxxxxx10110xxxxxxxxxx
15990                                                          uzp2.  */
15991                                                       return 265;
15992                                                     }
15993                                                 }
15994                                               else
15995                                                 {
15996                                                   if (((word >> 14) & 0x1) == 0)
15997                                                     {
15998                                                       /* 33222222222211111111110000000000
15999                                                          10987654321098765432109876543210
16000                                                          0x001110xx0xxxxxx01110xxxxxxxxxx
16001                                                          zip1.  */
16002                                                       return 264;
16003                                                     }
16004                                                   else
16005                                                     {
16006                                                       /* 33222222222211111111110000000000
16007                                                          10987654321098765432109876543210
16008                                                          0x001110xx0xxxxxx11110xxxxxxxxxx
16009                                                          zip2.  */
16010                                                       return 267;
16011                                                     }
16012                                                 }
16013                                             }
16014                                         }
16015                                     }
16016                                   else
16017                                     {
16018                                       if (((word >> 11) & 0x1) == 0)
16019                                         {
16020                                           if (((word >> 12) & 0x1) == 0)
16021                                             {
16022                                               if (((word >> 13) & 0x1) == 0)
16023                                                 {
16024                                                   if (((word >> 22) & 0x1) == 0)
16025                                                     {
16026                                                       /* 33222222222211111111110000000000
16027                                                          10987654321098765432109876543210
16028                                                          0x001110x00xxxxxxx0001xxxxxxxxxx
16029                                                          dup.  */
16030                                                       return 149;
16031                                                     }
16032                                                   else
16033                                                     {
16034                                                       if (((word >> 23) & 0x1) == 0)
16035                                                         {
16036                                                           /* 33222222222211111111110000000000
16037                                                              10987654321098765432109876543210
16038                                                              0x001110010xxxxxxx0001xxxxxxxxxx
16039                                                              fmaxnm.  */
16040                                                           return 292;
16041                                                         }
16042                                                       else
16043                                                         {
16044                                                           /* 33222222222211111111110000000000
16045                                                              10987654321098765432109876543210
16046                                                              0x001110110xxxxxxx0001xxxxxxxxxx
16047                                                              fminnm.  */
16048                                                           return 308;
16049                                                         }
16050                                                     }
16051                                                 }
16052                                               else
16053                                                 {
16054                                                   /* 33222222222211111111110000000000
16055                                                      10987654321098765432109876543210
16056                                                      0x001110xx0xxxxxxx1001xxxxxxxxxx
16057                                                      fcmeq.  */
16058                                                   return 300;
16059                                                 }
16060                                             }
16061                                           else
16062                                             {
16063                                               if (((word >> 13) & 0x1) == 0)
16064                                                 {
16065                                                   if (((word >> 15) & 0x1) == 0)
16066                                                     {
16067                                                       if (((word >> 23) & 0x1) == 0)
16068                                                         {
16069                                                           /* 33222222222211111111110000000000
16070                                                              10987654321098765432109876543210
16071                                                              0x0011100x0xxxxx0x0101xxxxxxxxxx
16072                                                              fadd.  */
16073                                                           return 296;
16074                                                         }
16075                                                       else
16076                                                         {
16077                                                           /* 33222222222211111111110000000000
16078                                                              10987654321098765432109876543210
16079                                                              0x0011101x0xxxxx0x0101xxxxxxxxxx
16080                                                              fsub.  */
16081                                                           return 312;
16082                                                         }
16083                                                     }
16084                                                   else
16085                                                     {
16086                                                       /* 33222222222211111111110000000000
16087                                                          10987654321098765432109876543210
16088                                                          0x001110xx0xxxxx1x0101xxxxxxxxxx
16089                                                          sdot.  */
16090                                                       return 2337;
16091                                                     }
16092                                                 }
16093                                               else
16094                                                 {
16095                                                   if (((word >> 23) & 0x1) == 0)
16096                                                     {
16097                                                       /* 33222222222211111111110000000000
16098                                                          10987654321098765432109876543210
16099                                                          0x0011100x0xxxxxxx1101xxxxxxxxxx
16100                                                          fmax.  */
16101                                                       return 302;
16102                                                     }
16103                                                   else
16104                                                     {
16105                                                       /* 33222222222211111111110000000000
16106                                                          10987654321098765432109876543210
16107                                                          0x0011101x0xxxxxxx1101xxxxxxxxxx
16108                                                          fmin.  */
16109                                                       return 314;
16110                                                     }
16111                                                 }
16112                                             }
16113                                         }
16114                                       else
16115                                         {
16116                                           if (((word >> 12) & 0x1) == 0)
16117                                             {
16118                                               if (((word >> 13) & 0x1) == 0)
16119                                                 {
16120                                                   if (((word >> 22) & 0x1) == 0)
16121                                                     {
16122                                                       /* 33222222222211111111110000000000
16123                                                          10987654321098765432109876543210
16124                                                          0x001110x00xxxxxxx0011xxxxxxxxxx
16125                                                          dup.  */
16126                                                       return 150;
16127                                                     }
16128                                                   else
16129                                                     {
16130                                                       if (((word >> 23) & 0x1) == 0)
16131                                                         {
16132                                                           /* 33222222222211111111110000000000
16133                                                              10987654321098765432109876543210
16134                                                              0x001110010xxxxxxx0011xxxxxxxxxx
16135                                                              fmla.  */
16136                                                           return 294;
16137                                                         }
16138                                                       else
16139                                                         {
16140                                                           /* 33222222222211111111110000000000
16141                                                              10987654321098765432109876543210
16142                                                              0x001110110xxxxxxx0011xxxxxxxxxx
16143                                                              fmls.  */
16144                                                           return 310;
16145                                                         }
16146                                                     }
16147                                                 }
16148                                               else
16149                                                 {
16150                                                   /* 33222222222211111111110000000000
16151                                                      10987654321098765432109876543210
16152                                                      0x001110xx0xxxxxxx1011xxxxxxxxxx
16153                                                      smov.  */
16154                                                   return 151;
16155                                                 }
16156                                             }
16157                                           else
16158                                             {
16159                                               if (((word >> 13) & 0x1) == 0)
16160                                                 {
16161                                                   if (((word >> 22) & 0x1) == 0)
16162                                                     {
16163                                                       /* 33222222222211111111110000000000
16164                                                          10987654321098765432109876543210
16165                                                          0x001110x00xxxxxxx0111xxxxxxxxxx
16166                                                          ins.  */
16167                                                       return 154;
16168                                                     }
16169                                                   else
16170                                                     {
16171                                                       /* 33222222222211111111110000000000
16172                                                          10987654321098765432109876543210
16173                                                          0x001110x10xxxxxxx0111xxxxxxxxxx
16174                                                          fmulx.  */
16175                                                       return 298;
16176                                                     }
16177                                                 }
16178                                               else
16179                                                 {
16180                                                   if (((word >> 22) & 0x1) == 0)
16181                                                     {
16182                                                       /* 33222222222211111111110000000000
16183                                                          10987654321098765432109876543210
16184                                                          0x001110x00xxxxxxx1111xxxxxxxxxx
16185                                                          umov.  */
16186                                                       return 152;
16187                                                     }
16188                                                   else
16189                                                     {
16190                                                       if (((word >> 23) & 0x1) == 0)
16191                                                         {
16192                                                           /* 33222222222211111111110000000000
16193                                                              10987654321098765432109876543210
16194                                                              0x001110010xxxxxxx1111xxxxxxxxxx
16195                                                              frecps.  */
16196                                                           return 304;
16197                                                         }
16198                                                       else
16199                                                         {
16200                                                           /* 33222222222211111111110000000000
16201                                                              10987654321098765432109876543210
16202                                                              0x001110110xxxxxxx1111xxxxxxxxxx
16203                                                              frsqrts.  */
16204                                                           return 316;
16205                                                         }
16206                                                     }
16207                                                 }
16208                                             }
16209                                         }
16210                                     }
16211                                 }
16212                               else
16213                                 {
16214                                   if (((word >> 22) & 0x1) == 0)
16215                                     {
16216                                       if (((word >> 23) & 0x1) == 0)
16217                                         {
16218                                           /* 33222222222211111111110000000000
16219                                              10987654321098765432109876543210
16220                                              1x001110000xxxxxxxxxxxxxxxxxxxxx
16221                                              eor3.  */
16222                                           return 2344;
16223                                         }
16224                                       else
16225                                         {
16226                                           /* 33222222222211111111110000000000
16227                                              10987654321098765432109876543210
16228                                              1x001110100xxxxxxxxxxxxxxxxxxxxx
16229                                              xar.  */
16230                                           return 2346;
16231                                         }
16232                                     }
16233                                   else
16234                                     {
16235                                       if (((word >> 15) & 0x1) == 0)
16236                                         {
16237                                           /* 33222222222211111111110000000000
16238                                              10987654321098765432109876543210
16239                                              1x001110x10xxxxx0xxxxxxxxxxxxxxx
16240                                              sm3ss1.  */
16241                                           return 2348;
16242                                         }
16243                                       else
16244                                         {
16245                                           if (((word >> 10) & 0x1) == 0)
16246                                             {
16247                                               if (((word >> 11) & 0x1) == 0)
16248                                                 {
16249                                                   if (((word >> 23) & 0x1) == 0)
16250                                                     {
16251                                                       /* 33222222222211111111110000000000
16252                                                          10987654321098765432109876543210
16253                                                          1x001110010xxxxx1xxx00xxxxxxxxxx
16254                                                          sm3tt1a.  */
16255                                                       return 2349;
16256                                                     }
16257                                                   else
16258                                                     {
16259                                                       /* 33222222222211111111110000000000
16260                                                          10987654321098765432109876543210
16261                                                          1x001110110xxxxx1xxx00xxxxxxxxxx
16262                                                          sha512su0.  */
16263                                                       return 2342;
16264                                                     }
16265                                                 }
16266                                               else
16267                                                 {
16268                                                   /* 33222222222211111111110000000000
16269                                                      10987654321098765432109876543210
16270                                                      1x001110x10xxxxx1xxx10xxxxxxxxxx
16271                                                      sm3tt2a.  */
16272                                                   return 2351;
16273                                                 }
16274                                             }
16275                                           else
16276                                             {
16277                                               if (((word >> 11) & 0x1) == 0)
16278                                                 {
16279                                                   if (((word >> 23) & 0x1) == 0)
16280                                                     {
16281                                                       /* 33222222222211111111110000000000
16282                                                          10987654321098765432109876543210
16283                                                          1x001110010xxxxx1xxx01xxxxxxxxxx
16284                                                          sm3tt1b.  */
16285                                                       return 2350;
16286                                                     }
16287                                                   else
16288                                                     {
16289                                                       /* 33222222222211111111110000000000
16290                                                          10987654321098765432109876543210
16291                                                          1x001110110xxxxx1xxx01xxxxxxxxxx
16292                                                          sm4e.  */
16293                                                       return 2355;
16294                                                     }
16295                                                 }
16296                                               else
16297                                                 {
16298                                                   /* 33222222222211111111110000000000
16299                                                      10987654321098765432109876543210
16300                                                      1x001110x10xxxxx1xxx11xxxxxxxxxx
16301                                                      sm3tt2b.  */
16302                                                   return 2352;
16303                                                 }
16304                                             }
16305                                         }
16306                                     }
16307                                 }
16308                             }
16309                           else
16310                             {
16311                               if (((word >> 10) & 0x1) == 0)
16312                                 {
16313                                   /* 33222222222211111111110000000000
16314                                      10987654321098765432109876543210
16315                                      xx101110xx0xxxxxxxxxx0xxxxxxxxxx
16316                                      ext.  */
16317                                   return 132;
16318                                 }
16319                               else
16320                                 {
16321                                   if (((word >> 15) & 0x1) == 0)
16322                                     {
16323                                       if (((word >> 22) & 0x1) == 0)
16324                                         {
16325                                           /* 33222222222211111111110000000000
16326                                              10987654321098765432109876543210
16327                                              xx101110x00xxxxx0xxxx1xxxxxxxxxx
16328                                              ins.  */
16329                                           return 156;
16330                                         }
16331                                       else
16332                                         {
16333                                           if (((word >> 11) & 0x1) == 0)
16334                                             {
16335                                               if (((word >> 12) & 0x1) == 0)
16336                                                 {
16337                                                   if (((word >> 13) & 0x1) == 0)
16338                                                     {
16339                                                       if (((word >> 23) & 0x1) == 0)
16340                                                         {
16341                                                           /* 33222222222211111111110000000000
16342                                                              10987654321098765432109876543210
16343                                                              xx101110010xxxxx0x0001xxxxxxxxxx
16344                                                              fmaxnmp.  */
16345                                                           return 343;
16346                                                         }
16347                                                       else
16348                                                         {
16349                                                           /* 33222222222211111111110000000000
16350                                                              10987654321098765432109876543210
16351                                                              xx101110110xxxxx0x0001xxxxxxxxxx
16352                                                              fminnmp.  */
16353                                                           return 359;
16354                                                         }
16355                                                     }
16356                                                   else
16357                                                     {
16358                                                       if (((word >> 23) & 0x1) == 0)
16359                                                         {
16360                                                           /* 33222222222211111111110000000000
16361                                                              10987654321098765432109876543210
16362                                                              xx101110010xxxxx0x1001xxxxxxxxxx
16363                                                              fcmge.  */
16364                                                           return 349;
16365                                                         }
16366                                                       else
16367                                                         {
16368                                                           /* 33222222222211111111110000000000
16369                                                              10987654321098765432109876543210
16370                                                              xx101110110xxxxx0x1001xxxxxxxxxx
16371                                                              fcmgt.  */
16372                                                           return 363;
16373                                                         }
16374                                                     }
16375                                                 }
16376                                               else
16377                                                 {
16378                                                   if (((word >> 13) & 0x1) == 0)
16379                                                     {
16380                                                       if (((word >> 23) & 0x1) == 0)
16381                                                         {
16382                                                           /* 33222222222211111111110000000000
16383                                                              10987654321098765432109876543210
16384                                                              xx101110010xxxxx0x0101xxxxxxxxxx
16385                                                              faddp.  */
16386                                                           return 345;
16387                                                         }
16388                                                       else
16389                                                         {
16390                                                           /* 33222222222211111111110000000000
16391                                                              10987654321098765432109876543210
16392                                                              xx101110110xxxxx0x0101xxxxxxxxxx
16393                                                              fabd.  */
16394                                                           return 361;
16395                                                         }
16396                                                     }
16397                                                   else
16398                                                     {
16399                                                       if (((word >> 23) & 0x1) == 0)
16400                                                         {
16401                                                           /* 33222222222211111111110000000000
16402                                                              10987654321098765432109876543210
16403                                                              xx101110010xxxxx0x1101xxxxxxxxxx
16404                                                              fmaxp.  */
16405                                                           return 353;
16406                                                         }
16407                                                       else
16408                                                         {
16409                                                           /* 33222222222211111111110000000000
16410                                                              10987654321098765432109876543210
16411                                                              xx101110110xxxxx0x1101xxxxxxxxxx
16412                                                              fminp.  */
16413                                                           return 367;
16414                                                         }
16415                                                     }
16416                                                 }
16417                                             }
16418                                           else
16419                                             {
16420                                               if (((word >> 12) & 0x1) == 0)
16421                                                 {
16422                                                   if (((word >> 23) & 0x1) == 0)
16423                                                     {
16424                                                       /* 33222222222211111111110000000000
16425                                                          10987654321098765432109876543210
16426                                                          xx101110010xxxxx0xx011xxxxxxxxxx
16427                                                          facge.  */
16428                                                       return 351;
16429                                                     }
16430                                                   else
16431                                                     {
16432                                                       /* 33222222222211111111110000000000
16433                                                          10987654321098765432109876543210
16434                                                          xx101110110xxxxx0xx011xxxxxxxxxx
16435                                                          facgt.  */
16436                                                       return 365;
16437                                                     }
16438                                                 }
16439                                               else
16440                                                 {
16441                                                   if (((word >> 13) & 0x1) == 0)
16442                                                     {
16443                                                       /* 33222222222211111111110000000000
16444                                                          10987654321098765432109876543210
16445                                                          xx101110x10xxxxx0x0111xxxxxxxxxx
16446                                                          fmul.  */
16447                                                       return 347;
16448                                                     }
16449                                                   else
16450                                                     {
16451                                                       /* 33222222222211111111110000000000
16452                                                          10987654321098765432109876543210
16453                                                          xx101110x10xxxxx0x1111xxxxxxxxxx
16454                                                          fdiv.  */
16455                                                       return 355;
16456                                                     }
16457                                                 }
16458                                             }
16459                                         }
16460                                     }
16461                                   else
16462                                     {
16463                                       if (((word >> 13) & 0x1) == 0)
16464                                         {
16465                                           if (((word >> 14) & 0x1) == 0)
16466                                             {
16467                                               if (((word >> 11) & 0x1) == 0)
16468                                                 {
16469                                                   if (((word >> 12) & 0x1) == 0)
16470                                                     {
16471                                                       /* 33222222222211111111110000000000
16472                                                          10987654321098765432109876543210
16473                                                          xx101110xx0xxxxx100001xxxxxxxxxx
16474                                                          sqrdmlah.  */
16475                                                       return 370;
16476                                                     }
16477                                                   else
16478                                                     {
16479                                                       /* 33222222222211111111110000000000
16480                                                          10987654321098765432109876543210
16481                                                          xx101110xx0xxxxx100101xxxxxxxxxx
16482                                                          udot.  */
16483                                                       return 2336;
16484                                                     }
16485                                                 }
16486                                               else
16487                                                 {
16488                                                   /* 33222222222211111111110000000000
16489                                                      10987654321098765432109876543210
16490                                                      xx101110xx0xxxxx100x11xxxxxxxxxx
16491                                                      sqrdmlsh.  */
16492                                                   return 371;
16493                                                 }
16494                                             }
16495                                           else
16496                                             {
16497                                               /* 33222222222211111111110000000000
16498                                                  10987654321098765432109876543210
16499                                                  xx101110xx0xxxxx110xx1xxxxxxxxxx
16500                                                  fcmla.  */
16501                                               return 372;
16502                                             }
16503                                         }
16504                                       else
16505                                         {
16506                                           /* 33222222222211111111110000000000
16507                                              10987654321098765432109876543210
16508                                              xx101110xx0xxxxx1x1xx1xxxxxxxxxx
16509                                              fcadd.  */
16510                                           return 373;
16511                                         }
16512                                     }
16513                                 }
16514                             }
16515                         }
16516                       else
16517                         {
16518                           if (((word >> 29) & 0x1) == 0)
16519                             {
16520                               if (((word >> 30) & 0x1) == 0)
16521                                 {
16522                                   if (((word >> 16) & 0x1) == 0)
16523                                     {
16524                                       if (((word >> 17) & 0x1) == 0)
16525                                         {
16526                                           /* 33222222222211111111110000000000
16527                                              10987654321098765432109876543210
16528                                              x0011110xx0xxx00xxxxxxxxxxxxxxxx
16529                                              fcvtzs.  */
16530                                           return 763;
16531                                         }
16532                                       else
16533                                         {
16534                                           /* 33222222222211111111110000000000
16535                                              10987654321098765432109876543210
16536                                              x0011110xx0xxx10xxxxxxxxxxxxxxxx
16537                                              scvtf.  */
16538                                           return 759;
16539                                         }
16540                                     }
16541                                   else
16542                                     {
16543                                       if (((word >> 17) & 0x1) == 0)
16544                                         {
16545                                           /* 33222222222211111111110000000000
16546                                              10987654321098765432109876543210
16547                                              x0011110xx0xxx01xxxxxxxxxxxxxxxx
16548                                              fcvtzu.  */
16549                                           return 765;
16550                                         }
16551                                       else
16552                                         {
16553                                           /* 33222222222211111111110000000000
16554                                              10987654321098765432109876543210
16555                                              x0011110xx0xxx11xxxxxxxxxxxxxxxx
16556                                              ucvtf.  */
16557                                           return 761;
16558                                         }
16559                                     }
16560                                 }
16561                               else
16562                                 {
16563                                   if (((word >> 10) & 0x1) == 0)
16564                                     {
16565                                       if (((word >> 12) & 0x1) == 0)
16566                                         {
16567                                           if (((word >> 13) & 0x1) == 0)
16568                                             {
16569                                               if (((word >> 14) & 0x1) == 0)
16570                                                 {
16571                                                   /* 33222222222211111111110000000000
16572                                                      10987654321098765432109876543210
16573                                                      x1011110xx0xxxxxx000x0xxxxxxxxxx
16574                                                      sha1c.  */
16575                                                   return 678;
16576                                                 }
16577                                               else
16578                                                 {
16579                                                   /* 33222222222211111111110000000000
16580                                                      10987654321098765432109876543210
16581                                                      x1011110xx0xxxxxx100x0xxxxxxxxxx
16582                                                      sha256h.  */
16583                                                   return 682;
16584                                                 }
16585                                             }
16586                                           else
16587                                             {
16588                                               if (((word >> 14) & 0x1) == 0)
16589                                                 {
16590                                                   /* 33222222222211111111110000000000
16591                                                      10987654321098765432109876543210
16592                                                      x1011110xx0xxxxxx010x0xxxxxxxxxx
16593                                                      sha1m.  */
16594                                                   return 680;
16595                                                 }
16596                                               else
16597                                                 {
16598                                                   /* 33222222222211111111110000000000
16599                                                      10987654321098765432109876543210
16600                                                      x1011110xx0xxxxxx110x0xxxxxxxxxx
16601                                                      sha256su1.  */
16602                                                   return 684;
16603                                                 }
16604                                             }
16605                                         }
16606                                       else
16607                                         {
16608                                           if (((word >> 13) & 0x1) == 0)
16609                                             {
16610                                               if (((word >> 14) & 0x1) == 0)
16611                                                 {
16612                                                   /* 33222222222211111111110000000000
16613                                                      10987654321098765432109876543210
16614                                                      x1011110xx0xxxxxx001x0xxxxxxxxxx
16615                                                      sha1p.  */
16616                                                   return 679;
16617                                                 }
16618                                               else
16619                                                 {
16620                                                   /* 33222222222211111111110000000000
16621                                                      10987654321098765432109876543210
16622                                                      x1011110xx0xxxxxx101x0xxxxxxxxxx
16623                                                      sha256h2.  */
16624                                                   return 683;
16625                                                 }
16626                                             }
16627                                           else
16628                                             {
16629                                               /* 33222222222211111111110000000000
16630                                                  10987654321098765432109876543210
16631                                                  x1011110xx0xxxxxxx11x0xxxxxxxxxx
16632                                                  sha1su0.  */
16633                                               return 681;
16634                                             }
16635                                         }
16636                                     }
16637                                   else
16638                                     {
16639                                       if (((word >> 11) & 0x1) == 0)
16640                                         {
16641                                           if (((word >> 13) & 0x1) == 0)
16642                                             {
16643                                               /* 33222222222211111111110000000000
16644                                                  10987654321098765432109876543210
16645                                                  x1011110xx0xxxxxxx0x01xxxxxxxxxx
16646                                                  dup.  */
16647                                               return 535;
16648                                             }
16649                                           else
16650                                             {
16651                                               /* 33222222222211111111110000000000
16652                                                  10987654321098765432109876543210
16653                                                  x1011110xx0xxxxxxx1x01xxxxxxxxxx
16654                                                  fcmeq.  */
16655                                               return 556;
16656                                             }
16657                                         }
16658                                       else
16659                                         {
16660                                           if (((word >> 13) & 0x1) == 0)
16661                                             {
16662                                               /* 33222222222211111111110000000000
16663                                                  10987654321098765432109876543210
16664                                                  x1011110xx0xxxxxxx0x11xxxxxxxxxx
16665                                                  fmulx.  */
16666                                               return 554;
16667                                             }
16668                                           else
16669                                             {
16670                                               if (((word >> 23) & 0x1) == 0)
16671                                                 {
16672                                                   /* 33222222222211111111110000000000
16673                                                      10987654321098765432109876543210
16674                                                      x10111100x0xxxxxxx1x11xxxxxxxxxx
16675                                                      frecps.  */
16676                                                   return 558;
16677                                                 }
16678                                               else
16679                                                 {
16680                                                   /* 33222222222211111111110000000000
16681                                                      10987654321098765432109876543210
16682                                                      x10111101x0xxxxxxx1x11xxxxxxxxxx
16683                                                      frsqrts.  */
16684                                                   return 560;
16685                                                 }
16686                                             }
16687                                         }
16688                                     }
16689                                 }
16690                             }
16691                           else
16692                             {
16693                               if (((word >> 11) & 0x1) == 0)
16694                                 {
16695                                   if (((word >> 12) & 0x1) == 0)
16696                                     {
16697                                       if (((word >> 13) & 0x1) == 0)
16698                                         {
16699                                           /* 33222222222211111111110000000000
16700                                              10987654321098765432109876543210
16701                                              xx111110xx0xxxxxxx000xxxxxxxxxxx
16702                                              sqrdmlah.  */
16703                                           return 588;
16704                                         }
16705                                       else
16706                                         {
16707                                           if (((word >> 23) & 0x1) == 0)
16708                                             {
16709                                               /* 33222222222211111111110000000000
16710                                                  10987654321098765432109876543210
16711                                                  xx1111100x0xxxxxxx100xxxxxxxxxxx
16712                                                  fcmge.  */
16713                                               return 573;
16714                                             }
16715                                           else
16716                                             {
16717                                               /* 33222222222211111111110000000000
16718                                                  10987654321098765432109876543210
16719                                                  xx1111101x0xxxxxxx100xxxxxxxxxxx
16720                                                  fcmgt.  */
16721                                               return 579;
16722                                             }
16723                                         }
16724                                     }
16725                                   else
16726                                     {
16727                                       /* 33222222222211111111110000000000
16728                                          10987654321098765432109876543210
16729                                          xx111110xx0xxxxxxxx10xxxxxxxxxxx
16730                                          fabd.  */
16731                                       return 577;
16732                                     }
16733                                 }
16734                               else
16735                                 {
16736                                   if (((word >> 13) & 0x1) == 0)
16737                                     {
16738                                       /* 33222222222211111111110000000000
16739                                          10987654321098765432109876543210
16740                                          xx111110xx0xxxxxxx0x1xxxxxxxxxxx
16741                                          sqrdmlsh.  */
16742                                       return 589;
16743                                     }
16744                                   else
16745                                     {
16746                                       if (((word >> 23) & 0x1) == 0)
16747                                         {
16748                                           /* 33222222222211111111110000000000
16749                                              10987654321098765432109876543210
16750                                              xx1111100x0xxxxxxx1x1xxxxxxxxxxx
16751                                              facge.  */
16752                                           return 575;
16753                                         }
16754                                       else
16755                                         {
16756                                           /* 33222222222211111111110000000000
16757                                              10987654321098765432109876543210
16758                                              xx1111101x0xxxxxxx1x1xxxxxxxxxxx
16759                                              facgt.  */
16760                                           return 581;
16761                                         }
16762                                     }
16763                                 }
16764                             }
16765                         }
16766                     }
16767                   else
16768                     {
16769                       if (((word >> 28) & 0x1) == 0)
16770                         {
16771                           if (((word >> 15) & 0x1) == 0)
16772                             {
16773                               if (((word >> 29) & 0x1) == 0)
16774                                 {
16775                                   if (((word >> 31) & 0x1) == 0)
16776                                     {
16777                                       if (((word >> 10) & 0x1) == 0)
16778                                         {
16779                                           if (((word >> 11) & 0x1) == 0)
16780                                             {
16781                                               if (((word >> 12) & 0x1) == 0)
16782                                                 {
16783                                                   if (((word >> 13) & 0x1) == 0)
16784                                                     {
16785                                                       if (((word >> 14) & 0x1) == 0)
16786                                                         {
16787                                                           if (((word >> 30) & 0x1) == 0)
16788                                                             {
16789                                                               /* 33222222222211111111110000000000
16790                                                                  10987654321098765432109876543210
16791                                                                  00001110xx1xxxxx000000xxxxxxxxxx
16792                                                                  saddl.  */
16793                                                               return 44;
16794                                                             }
16795                                                           else
16796                                                             {
16797                                                               /* 33222222222211111111110000000000
16798                                                                  10987654321098765432109876543210
16799                                                                  01001110xx1xxxxx000000xxxxxxxxxx
16800                                                                  saddl2.  */
16801                                                               return 45;
16802                                                             }
16803                                                         }
16804                                                       else
16805                                                         {
16806                                                           if (((word >> 30) & 0x1) == 0)
16807                                                             {
16808                                                               /* 33222222222211111111110000000000
16809                                                                  10987654321098765432109876543210
16810                                                                  00001110xx1xxxxx010000xxxxxxxxxx
16811                                                                  addhn.  */
16812                                                               return 52;
16813                                                             }
16814                                                           else
16815                                                             {
16816                                                               /* 33222222222211111111110000000000
16817                                                                  10987654321098765432109876543210
16818                                                                  01001110xx1xxxxx010000xxxxxxxxxx
16819                                                                  addhn2.  */
16820                                                               return 53;
16821                                                             }
16822                                                         }
16823                                                     }
16824                                                   else
16825                                                     {
16826                                                       if (((word >> 14) & 0x1) == 0)
16827                                                         {
16828                                                           if (((word >> 30) & 0x1) == 0)
16829                                                             {
16830                                                               /* 33222222222211111111110000000000
16831                                                                  10987654321098765432109876543210
16832                                                                  00001110xx1xxxxx001000xxxxxxxxxx
16833                                                                  ssubl.  */
16834                                                               return 48;
16835                                                             }
16836                                                           else
16837                                                             {
16838                                                               /* 33222222222211111111110000000000
16839                                                                  10987654321098765432109876543210
16840                                                                  01001110xx1xxxxx001000xxxxxxxxxx
16841                                                                  ssubl2.  */
16842                                                               return 49;
16843                                                             }
16844                                                         }
16845                                                       else
16846                                                         {
16847                                                           if (((word >> 30) & 0x1) == 0)
16848                                                             {
16849                                                               /* 33222222222211111111110000000000
16850                                                                  10987654321098765432109876543210
16851                                                                  00001110xx1xxxxx011000xxxxxxxxxx
16852                                                                  subhn.  */
16853                                                               return 56;
16854                                                             }
16855                                                           else
16856                                                             {
16857                                                               /* 33222222222211111111110000000000
16858                                                                  10987654321098765432109876543210
16859                                                                  01001110xx1xxxxx011000xxxxxxxxxx
16860                                                                  subhn2.  */
16861                                                               return 57;
16862                                                             }
16863                                                         }
16864                                                     }
16865                                                 }
16866                                               else
16867                                                 {
16868                                                   if (((word >> 13) & 0x1) == 0)
16869                                                     {
16870                                                       if (((word >> 14) & 0x1) == 0)
16871                                                         {
16872                                                           if (((word >> 30) & 0x1) == 0)
16873                                                             {
16874                                                               /* 33222222222211111111110000000000
16875                                                                  10987654321098765432109876543210
16876                                                                  00001110xx1xxxxx000100xxxxxxxxxx
16877                                                                  saddw.  */
16878                                                               return 46;
16879                                                             }
16880                                                           else
16881                                                             {
16882                                                               /* 33222222222211111111110000000000
16883                                                                  10987654321098765432109876543210
16884                                                                  01001110xx1xxxxx000100xxxxxxxxxx
16885                                                                  saddw2.  */
16886                                                               return 47;
16887                                                             }
16888                                                         }
16889                                                       else
16890                                                         {
16891                                                           if (((word >> 30) & 0x1) == 0)
16892                                                             {
16893                                                               /* 33222222222211111111110000000000
16894                                                                  10987654321098765432109876543210
16895                                                                  00001110xx1xxxxx010100xxxxxxxxxx
16896                                                                  sabal.  */
16897                                                               return 54;
16898                                                             }
16899                                                           else
16900                                                             {
16901                                                               /* 33222222222211111111110000000000
16902                                                                  10987654321098765432109876543210
16903                                                                  01001110xx1xxxxx010100xxxxxxxxxx
16904                                                                  sabal2.  */
16905                                                               return 55;
16906                                                             }
16907                                                         }
16908                                                     }
16909                                                   else
16910                                                     {
16911                                                       if (((word >> 14) & 0x1) == 0)
16912                                                         {
16913                                                           if (((word >> 30) & 0x1) == 0)
16914                                                             {
16915                                                               /* 33222222222211111111110000000000
16916                                                                  10987654321098765432109876543210
16917                                                                  00001110xx1xxxxx001100xxxxxxxxxx
16918                                                                  ssubw.  */
16919                                                               return 50;
16920                                                             }
16921                                                           else
16922                                                             {
16923                                                               /* 33222222222211111111110000000000
16924                                                                  10987654321098765432109876543210
16925                                                                  01001110xx1xxxxx001100xxxxxxxxxx
16926                                                                  ssubw2.  */
16927                                                               return 51;
16928                                                             }
16929                                                         }
16930                                                       else
16931                                                         {
16932                                                           if (((word >> 30) & 0x1) == 0)
16933                                                             {
16934                                                               /* 33222222222211111111110000000000
16935                                                                  10987654321098765432109876543210
16936                                                                  00001110xx1xxxxx011100xxxxxxxxxx
16937                                                                  sabdl.  */
16938                                                               return 58;
16939                                                             }
16940                                                           else
16941                                                             {
16942                                                               /* 33222222222211111111110000000000
16943                                                                  10987654321098765432109876543210
16944                                                                  01001110xx1xxxxx011100xxxxxxxxxx
16945                                                                  sabdl2.  */
16946                                                               return 59;
16947                                                             }
16948                                                         }
16949                                                     }
16950                                                 }
16951                                             }
16952                                           else
16953                                             {
16954                                               if (((word >> 12) & 0x1) == 0)
16955                                                 {
16956                                                   if (((word >> 13) & 0x1) == 0)
16957                                                     {
16958                                                       if (((word >> 14) & 0x1) == 0)
16959                                                         {
16960                                                           /* 33222222222211111111110000000000
16961                                                              10987654321098765432109876543210
16962                                                              0x001110xx1xxxxx000010xxxxxxxxxx
16963                                                              rev64.  */
16964                                                           return 162;
16965                                                         }
16966                                                       else
16967                                                         {
16968                                                           if (((word >> 16) & 0x1) == 0)
16969                                                             {
16970                                                               if (((word >> 19) & 0x1) == 0)
16971                                                                 {
16972                                                                   /* 33222222222211111111110000000000
16973                                                                      10987654321098765432109876543210
16974                                                                      0x001110xx1x0xx0010010xxxxxxxxxx
16975                                                                      cls.  */
16976                                                                   return 166;
16977                                                                 }
16978                                                               else
16979                                                                 {
16980                                                                   /* 33222222222211111111110000000000
16981                                                                      10987654321098765432109876543210
16982                                                                      0x001110xx1x1xx0010010xxxxxxxxxx
16983                                                                      aese.  */
16984                                                                   return 671;
16985                                                                 }
16986                                                             }
16987                                                           else
16988                                                             {
16989                                                               if (((word >> 30) & 0x1) == 0)
16990                                                                 {
16991                                                                   /* 33222222222211111111110000000000
16992                                                                      10987654321098765432109876543210
16993                                                                      00001110xx1xxxx1010010xxxxxxxxxx
16994                                                                      sqxtn.  */
16995                                                                   return 176;
16996                                                                 }
16997                                                               else
16998                                                                 {
16999                                                                   /* 33222222222211111111110000000000
17000                                                                      10987654321098765432109876543210
17001                                                                      01001110xx1xxxx1010010xxxxxxxxxx
17002                                                                      sqxtn2.  */
17003                                                                   return 177;
17004                                                                 }
17005                                                             }
17006                                                         }
17007                                                     }
17008                                                   else
17009                                                     {
17010                                                       if (((word >> 14) & 0x1) == 0)
17011                                                         {
17012                                                           if (((word >> 16) & 0x1) == 0)
17013                                                             {
17014                                                               /* 33222222222211111111110000000000
17015                                                                  10987654321098765432109876543210
17016                                                                  0x001110xx1xxxx0001010xxxxxxxxxx
17017                                                                  saddlp.  */
17018                                                               return 164;
17019                                                             }
17020                                                           else
17021                                                             {
17022                                                               if (((word >> 30) & 0x1) == 0)
17023                                                                 {
17024                                                                   /* 33222222222211111111110000000000
17025                                                                      10987654321098765432109876543210
17026                                                                      00001110xx1xxxx1001010xxxxxxxxxx
17027                                                                      xtn.  */
17028                                                                   return 174;
17029                                                                 }
17030                                                               else
17031                                                                 {
17032                                                                   /* 33222222222211111111110000000000
17033                                                                      10987654321098765432109876543210
17034                                                                      01001110xx1xxxx1001010xxxxxxxxxx
17035                                                                      xtn2.  */
17036                                                                   return 175;
17037                                                                 }
17038                                                             }
17039                                                         }
17040                                                       else
17041                                                         {
17042                                                           if (((word >> 16) & 0x1) == 0)
17043                                                             {
17044                                                               if (((word >> 19) & 0x1) == 0)
17045                                                                 {
17046                                                                   /* 33222222222211111111110000000000
17047                                                                      10987654321098765432109876543210
17048                                                                      0x001110xx1x0xx0011010xxxxxxxxxx
17049                                                                      sadalp.  */
17050                                                                   return 168;
17051                                                                 }
17052                                                               else
17053                                                                 {
17054                                                                   /* 33222222222211111111110000000000
17055                                                                      10987654321098765432109876543210
17056                                                                      0x001110xx1x1xx0011010xxxxxxxxxx
17057                                                                      aesmc.  */
17058                                                                   return 673;
17059                                                                 }
17060                                                             }
17061                                                           else
17062                                                             {
17063                                                               if (((word >> 30) & 0x1) == 0)
17064                                                                 {
17065                                                                   /* 33222222222211111111110000000000
17066                                                                      10987654321098765432109876543210
17067                                                                      00001110xx1xxxx1011010xxxxxxxxxx
17068                                                                      fcvtn.  */
17069                                                                   return 178;
17070                                                                 }
17071                                                               else
17072                                                                 {
17073                                                                   /* 33222222222211111111110000000000
17074                                                                      10987654321098765432109876543210
17075                                                                      01001110xx1xxxx1011010xxxxxxxxxx
17076                                                                      fcvtn2.  */
17077                                                                   return 179;
17078                                                                 }
17079                                                             }
17080                                                         }
17081                                                     }
17082                                                 }
17083                                               else
17084                                                 {
17085                                                   if (((word >> 13) & 0x1) == 0)
17086                                                     {
17087                                                       if (((word >> 14) & 0x1) == 0)
17088                                                         {
17089                                                           /* 33222222222211111111110000000000
17090                                                              10987654321098765432109876543210
17091                                                              0x001110xx1xxxxx000110xxxxxxxxxx
17092                                                              rev16.  */
17093                                                           return 163;
17094                                                         }
17095                                                       else
17096                                                         {
17097                                                           if (((word >> 19) & 0x1) == 0)
17098                                                             {
17099                                                               /* 33222222222211111111110000000000
17100                                                                  10987654321098765432109876543210
17101                                                                  0x001110xx1x0xxx010110xxxxxxxxxx
17102                                                                  cnt.  */
17103                                                               return 167;
17104                                                             }
17105                                                           else
17106                                                             {
17107                                                               /* 33222222222211111111110000000000
17108                                                                  10987654321098765432109876543210
17109                                                                  0x001110xx1x1xxx010110xxxxxxxxxx
17110                                                                  aesd.  */
17111                                                               return 672;
17112                                                             }
17113                                                         }
17114                                                     }
17115                                                   else
17116                                                     {
17117                                                       if (((word >> 14) & 0x1) == 0)
17118                                                         {
17119                                                           if (((word >> 20) & 0x1) == 0)
17120                                                             {
17121                                                               /* 33222222222211111111110000000000
17122                                                                  10987654321098765432109876543210
17123                                                                  0x001110xx10xxxx001110xxxxxxxxxx
17124                                                                  suqadd.  */
17125                                                               return 165;
17126                                                             }
17127                                                           else
17128                                                             {
17129                                                               /* 33222222222211111111110000000000
17130                                                                  10987654321098765432109876543210
17131                                                                  0x001110xx11xxxx001110xxxxxxxxxx
17132                                                                  saddlv.  */
17133                                                               return 29;
17134                                                             }
17135                                                         }
17136                                                       else
17137                                                         {
17138                                                           if (((word >> 16) & 0x1) == 0)
17139                                                             {
17140                                                               if (((word >> 19) & 0x1) == 0)
17141                                                                 {
17142                                                                   /* 33222222222211111111110000000000
17143                                                                      10987654321098765432109876543210
17144                                                                      0x001110xx1x0xx0011110xxxxxxxxxx
17145                                                                      sqabs.  */
17146                                                                   return 169;
17147                                                                 }
17148                                                               else
17149                                                                 {
17150                                                                   /* 33222222222211111111110000000000
17151                                                                      10987654321098765432109876543210
17152                                                                      0x001110xx1x1xx0011110xxxxxxxxxx
17153                                                                      aesimc.  */
17154                                                                   return 674;
17155                                                                 }
17156                                                             }
17157                                                           else
17158                                                             {
17159                                                               if (((word >> 30) & 0x1) == 0)
17160                                                                 {
17161                                                                   /* 33222222222211111111110000000000
17162                                                                      10987654321098765432109876543210
17163                                                                      00001110xx1xxxx1011110xxxxxxxxxx
17164                                                                      fcvtl.  */
17165                                                                   return 180;
17166                                                                 }
17167                                                               else
17168                                                                 {
17169                                                                   /* 33222222222211111111110000000000
17170                                                                      10987654321098765432109876543210
17171                                                                      01001110xx1xxxx1011110xxxxxxxxxx
17172                                                                      fcvtl2.  */
17173                                                                   return 181;
17174                                                                 }
17175                                                             }
17176                                                         }
17177                                                     }
17178                                                 }
17179                                             }
17180                                         }
17181                                       else
17182                                         {
17183                                           if (((word >> 11) & 0x1) == 0)
17184                                             {
17185                                               if (((word >> 12) & 0x1) == 0)
17186                                                 {
17187                                                   if (((word >> 13) & 0x1) == 0)
17188                                                     {
17189                                                       if (((word >> 14) & 0x1) == 0)
17190                                                         {
17191                                                           /* 33222222222211111111110000000000
17192                                                              10987654321098765432109876543210
17193                                                              0x001110xx1xxxxx000001xxxxxxxxxx
17194                                                              shadd.  */
17195                                                           return 268;
17196                                                         }
17197                                                       else
17198                                                         {
17199                                                           /* 33222222222211111111110000000000
17200                                                              10987654321098765432109876543210
17201                                                              0x001110xx1xxxxx010001xxxxxxxxxx
17202                                                              sshl.  */
17203                                                           return 275;
17204                                                         }
17205                                                     }
17206                                                   else
17207                                                     {
17208                                                       if (((word >> 14) & 0x1) == 0)
17209                                                         {
17210                                                           /* 33222222222211111111110000000000
17211                                                              10987654321098765432109876543210
17212                                                              0x001110xx1xxxxx001001xxxxxxxxxx
17213                                                              shsub.  */
17214                                                           return 271;
17215                                                         }
17216                                                       else
17217                                                         {
17218                                                           /* 33222222222211111111110000000000
17219                                                              10987654321098765432109876543210
17220                                                              0x001110xx1xxxxx011001xxxxxxxxxx
17221                                                              smax.  */
17222                                                           return 279;
17223                                                         }
17224                                                     }
17225                                                 }
17226                                               else
17227                                                 {
17228                                                   if (((word >> 13) & 0x1) == 0)
17229                                                     {
17230                                                       if (((word >> 14) & 0x1) == 0)
17231                                                         {
17232                                                           /* 33222222222211111111110000000000
17233                                                              10987654321098765432109876543210
17234                                                              0x001110xx1xxxxx000101xxxxxxxxxx
17235                                                              srhadd.  */
17236                                                           return 270;
17237                                                         }
17238                                                       else
17239                                                         {
17240                                                           /* 33222222222211111111110000000000
17241                                                              10987654321098765432109876543210
17242                                                              0x001110xx1xxxxx010101xxxxxxxxxx
17243                                                              srshl.  */
17244                                                           return 277;
17245                                                         }
17246                                                     }
17247                                                   else
17248                                                     {
17249                                                       if (((word >> 14) & 0x1) == 0)
17250                                                         {
17251                                                           /* 33222222222211111111110000000000
17252                                                              10987654321098765432109876543210
17253                                                              0x001110xx1xxxxx001101xxxxxxxxxx
17254                                                              cmgt.  */
17255                                                           return 273;
17256                                                         }
17257                                                       else
17258                                                         {
17259                                                           /* 33222222222211111111110000000000
17260                                                              10987654321098765432109876543210
17261                                                              0x001110xx1xxxxx011101xxxxxxxxxx
17262                                                              sabd.  */
17263                                                           return 281;
17264                                                         }
17265                                                     }
17266                                                 }
17267                                             }
17268                                           else
17269                                             {
17270                                               if (((word >> 12) & 0x1) == 0)
17271                                                 {
17272                                                   if (((word >> 13) & 0x1) == 0)
17273                                                     {
17274                                                       if (((word >> 14) & 0x1) == 0)
17275                                                         {
17276                                                           /* 33222222222211111111110000000000
17277                                                              10987654321098765432109876543210
17278                                                              0x001110xx1xxxxx000011xxxxxxxxxx
17279                                                              sqadd.  */
17280                                                           return 269;
17281                                                         }
17282                                                       else
17283                                                         {
17284                                                           /* 33222222222211111111110000000000
17285                                                              10987654321098765432109876543210
17286                                                              0x001110xx1xxxxx010011xxxxxxxxxx
17287                                                              sqshl.  */
17288                                                           return 276;
17289                                                         }
17290                                                     }
17291                                                   else
17292                                                     {
17293                                                       if (((word >> 14) & 0x1) == 0)
17294                                                         {
17295                                                           /* 33222222222211111111110000000000
17296                                                              10987654321098765432109876543210
17297                                                              0x001110xx1xxxxx001011xxxxxxxxxx
17298                                                              sqsub.  */
17299                                                           return 272;
17300                                                         }
17301                                                       else
17302                                                         {
17303                                                           /* 33222222222211111111110000000000
17304                                                              10987654321098765432109876543210
17305                                                              0x001110xx1xxxxx011011xxxxxxxxxx
17306                                                              smin.  */
17307                                                           return 280;
17308                                                         }
17309                                                     }
17310                                                 }
17311                                               else
17312                                                 {
17313                                                   if (((word >> 13) & 0x1) == 0)
17314                                                     {
17315                                                       if (((word >> 14) & 0x1) == 0)
17316                                                         {
17317                                                           if (((word >> 22) & 0x1) == 0)
17318                                                             {
17319                                                               if (((word >> 23) & 0x1) == 0)
17320                                                                 {
17321                                                                   /* 33222222222211111111110000000000
17322                                                                      10987654321098765432109876543210
17323                                                                      0x001110001xxxxx000111xxxxxxxxxx
17324                                                                      and.  */
17325                                                                   return 305;
17326                                                                 }
17327                                                               else
17328                                                                 {
17329                                                                   /* 33222222222211111111110000000000
17330                                                                      10987654321098765432109876543210
17331                                                                      0x001110101xxxxx000111xxxxxxxxxx
17332                                                                      orr.  */
17333                                                                   return 317;
17334                                                                 }
17335                                                             }
17336                                                           else
17337                                                             {
17338                                                               if (((word >> 23) & 0x1) == 0)
17339                                                                 {
17340                                                                   /* 33222222222211111111110000000000
17341                                                                      10987654321098765432109876543210
17342                                                                      0x001110011xxxxx000111xxxxxxxxxx
17343                                                                      bic.  */
17344                                                                   return 306;
17345                                                                 }
17346                                                               else
17347                                                                 {
17348                                                                   /* 33222222222211111111110000000000
17349                                                                      10987654321098765432109876543210
17350                                                                      0x001110111xxxxx000111xxxxxxxxxx
17351                                                                      orn.  */
17352                                                                   return 319;
17353                                                                 }
17354                                                             }
17355                                                         }
17356                                                       else
17357                                                         {
17358                                                           /* 33222222222211111111110000000000
17359                                                              10987654321098765432109876543210
17360                                                              0x001110xx1xxxxx010111xxxxxxxxxx
17361                                                              sqrshl.  */
17362                                                           return 278;
17363                                                         }
17364                                                     }
17365                                                   else
17366                                                     {
17367                                                       if (((word >> 14) & 0x1) == 0)
17368                                                         {
17369                                                           /* 33222222222211111111110000000000
17370                                                              10987654321098765432109876543210
17371                                                              0x001110xx1xxxxx001111xxxxxxxxxx
17372                                                              cmge.  */
17373                                                           return 274;
17374                                                         }
17375                                                       else
17376                                                         {
17377                                                           /* 33222222222211111111110000000000
17378                                                              10987654321098765432109876543210
17379                                                              0x001110xx1xxxxx011111xxxxxxxxxx
17380                                                              saba.  */
17381                                                           return 282;
17382                                                         }
17383                                                     }
17384                                                 }
17385                                             }
17386                                         }
17387                                     }
17388                                   else
17389                                     {
17390                                       /* 33222222222211111111110000000000
17391                                          10987654321098765432109876543210
17392                                          1x001110xx1xxxxx0xxxxxxxxxxxxxxx
17393                                          bcax.  */
17394                                       return 2347;
17395                                     }
17396                                 }
17397                               else
17398                                 {
17399                                   if (((word >> 10) & 0x1) == 0)
17400                                     {
17401                                       if (((word >> 11) & 0x1) == 0)
17402                                         {
17403                                           if (((word >> 12) & 0x1) == 0)
17404                                             {
17405                                               if (((word >> 13) & 0x1) == 0)
17406                                                 {
17407                                                   if (((word >> 14) & 0x1) == 0)
17408                                                     {
17409                                                       if (((word >> 30) & 0x1) == 0)
17410                                                         {
17411                                                           /* 33222222222211111111110000000000
17412                                                              10987654321098765432109876543210
17413                                                              x0101110xx1xxxxx000000xxxxxxxxxx
17414                                                              uaddl.  */
17415                                                           return 76;
17416                                                         }
17417                                                       else
17418                                                         {
17419                                                           /* 33222222222211111111110000000000
17420                                                              10987654321098765432109876543210
17421                                                              x1101110xx1xxxxx000000xxxxxxxxxx
17422                                                              uaddl2.  */
17423                                                           return 77;
17424                                                         }
17425                                                     }
17426                                                   else
17427                                                     {
17428                                                       if (((word >> 30) & 0x1) == 0)
17429                                                         {
17430                                                           /* 33222222222211111111110000000000
17431                                                              10987654321098765432109876543210
17432                                                              x0101110xx1xxxxx010000xxxxxxxxxx
17433                                                              raddhn.  */
17434                                                           return 84;
17435                                                         }
17436                                                       else
17437                                                         {
17438                                                           /* 33222222222211111111110000000000
17439                                                              10987654321098765432109876543210
17440                                                              x1101110xx1xxxxx010000xxxxxxxxxx
17441                                                              raddhn2.  */
17442                                                           return 85;
17443                                                         }
17444                                                     }
17445                                                 }
17446                                               else
17447                                                 {
17448                                                   if (((word >> 14) & 0x1) == 0)
17449                                                     {
17450                                                       if (((word >> 30) & 0x1) == 0)
17451                                                         {
17452                                                           /* 33222222222211111111110000000000
17453                                                              10987654321098765432109876543210
17454                                                              x0101110xx1xxxxx001000xxxxxxxxxx
17455                                                              usubl.  */
17456                                                           return 80;
17457                                                         }
17458                                                       else
17459                                                         {
17460                                                           /* 33222222222211111111110000000000
17461                                                              10987654321098765432109876543210
17462                                                              x1101110xx1xxxxx001000xxxxxxxxxx
17463                                                              usubl2.  */
17464                                                           return 81;
17465                                                         }
17466                                                     }
17467                                                   else
17468                                                     {
17469                                                       if (((word >> 30) & 0x1) == 0)
17470                                                         {
17471                                                           /* 33222222222211111111110000000000
17472                                                              10987654321098765432109876543210
17473                                                              x0101110xx1xxxxx011000xxxxxxxxxx
17474                                                              rsubhn.  */
17475                                                           return 88;
17476                                                         }
17477                                                       else
17478                                                         {
17479                                                           /* 33222222222211111111110000000000
17480                                                              10987654321098765432109876543210
17481                                                              x1101110xx1xxxxx011000xxxxxxxxxx
17482                                                              rsubhn2.  */
17483                                                           return 89;
17484                                                         }
17485                                                     }
17486                                                 }
17487                                             }
17488                                           else
17489                                             {
17490                                               if (((word >> 13) & 0x1) == 0)
17491                                                 {
17492                                                   if (((word >> 14) & 0x1) == 0)
17493                                                     {
17494                                                       if (((word >> 30) & 0x1) == 0)
17495                                                         {
17496                                                           /* 33222222222211111111110000000000
17497                                                              10987654321098765432109876543210
17498                                                              x0101110xx1xxxxx000100xxxxxxxxxx
17499                                                              uaddw.  */
17500                                                           return 78;
17501                                                         }
17502                                                       else
17503                                                         {
17504                                                           /* 33222222222211111111110000000000
17505                                                              10987654321098765432109876543210
17506                                                              x1101110xx1xxxxx000100xxxxxxxxxx
17507                                                              uaddw2.  */
17508                                                           return 79;
17509                                                         }
17510                                                     }
17511                                                   else
17512                                                     {
17513                                                       if (((word >> 30) & 0x1) == 0)
17514                                                         {
17515                                                           /* 33222222222211111111110000000000
17516                                                              10987654321098765432109876543210
17517                                                              x0101110xx1xxxxx010100xxxxxxxxxx
17518                                                              uabal.  */
17519                                                           return 86;
17520                                                         }
17521                                                       else
17522                                                         {
17523                                                           /* 33222222222211111111110000000000
17524                                                              10987654321098765432109876543210
17525                                                              x1101110xx1xxxxx010100xxxxxxxxxx
17526                                                              uabal2.  */
17527                                                           return 87;
17528                                                         }
17529                                                     }
17530                                                 }
17531                                               else
17532                                                 {
17533                                                   if (((word >> 14) & 0x1) == 0)
17534                                                     {
17535                                                       if (((word >> 30) & 0x1) == 0)
17536                                                         {
17537                                                           /* 33222222222211111111110000000000
17538                                                              10987654321098765432109876543210
17539                                                              x0101110xx1xxxxx001100xxxxxxxxxx
17540                                                              usubw.  */
17541                                                           return 82;
17542                                                         }
17543                                                       else
17544                                                         {
17545                                                           /* 33222222222211111111110000000000
17546                                                              10987654321098765432109876543210
17547                                                              x1101110xx1xxxxx001100xxxxxxxxxx
17548                                                              usubw2.  */
17549                                                           return 83;
17550                                                         }
17551                                                     }
17552                                                   else
17553                                                     {
17554                                                       if (((word >> 30) & 0x1) == 0)
17555                                                         {
17556                                                           /* 33222222222211111111110000000000
17557                                                              10987654321098765432109876543210
17558                                                              x0101110xx1xxxxx011100xxxxxxxxxx
17559                                                              uabdl.  */
17560                                                           return 90;
17561                                                         }
17562                                                       else
17563                                                         {
17564                                                           /* 33222222222211111111110000000000
17565                                                              10987654321098765432109876543210
17566                                                              x1101110xx1xxxxx011100xxxxxxxxxx
17567                                                              uabdl2.  */
17568                                                           return 91;
17569                                                         }
17570                                                     }
17571                                                 }
17572                                             }
17573                                         }
17574                                       else
17575                                         {
17576                                           if (((word >> 12) & 0x1) == 0)
17577                                             {
17578                                               if (((word >> 13) & 0x1) == 0)
17579                                                 {
17580                                                   if (((word >> 14) & 0x1) == 0)
17581                                                     {
17582                                                       /* 33222222222211111111110000000000
17583                                                          10987654321098765432109876543210
17584                                                          xx101110xx1xxxxx000010xxxxxxxxxx
17585                                                          rev32.  */
17586                                                       return 213;
17587                                                     }
17588                                                   else
17589                                                     {
17590                                                       if (((word >> 16) & 0x1) == 0)
17591                                                         {
17592                                                           /* 33222222222211111111110000000000
17593                                                              10987654321098765432109876543210
17594                                                              xx101110xx1xxxx0010010xxxxxxxxxx
17595                                                              clz.  */
17596                                                           return 216;
17597                                                         }
17598                                                       else
17599                                                         {
17600                                                           if (((word >> 30) & 0x1) == 0)
17601                                                             {
17602                                                               /* 33222222222211111111110000000000
17603                                                                  10987654321098765432109876543210
17604                                                                  x0101110xx1xxxx1010010xxxxxxxxxx
17605                                                                  uqxtn.  */
17606                                                               return 226;
17607                                                             }
17608                                                           else
17609                                                             {
17610                                                               /* 33222222222211111111110000000000
17611                                                                  10987654321098765432109876543210
17612                                                                  x1101110xx1xxxx1010010xxxxxxxxxx
17613                                                                  uqxtn2.  */
17614                                                               return 227;
17615                                                             }
17616                                                         }
17617                                                     }
17618                                                 }
17619                                               else
17620                                                 {
17621                                                   if (((word >> 14) & 0x1) == 0)
17622                                                     {
17623                                                       if (((word >> 16) & 0x1) == 0)
17624                                                         {
17625                                                           /* 33222222222211111111110000000000
17626                                                              10987654321098765432109876543210
17627                                                              xx101110xx1xxxx0001010xxxxxxxxxx
17628                                                              uaddlp.  */
17629                                                           return 214;
17630                                                         }
17631                                                       else
17632                                                         {
17633                                                           if (((word >> 30) & 0x1) == 0)
17634                                                             {
17635                                                               /* 33222222222211111111110000000000
17636                                                                  10987654321098765432109876543210
17637                                                                  x0101110xx1xxxx1001010xxxxxxxxxx
17638                                                                  sqxtun.  */
17639                                                               return 222;
17640                                                             }
17641                                                           else
17642                                                             {
17643                                                               /* 33222222222211111111110000000000
17644                                                                  10987654321098765432109876543210
17645                                                                  x1101110xx1xxxx1001010xxxxxxxxxx
17646                                                                  sqxtun2.  */
17647                                                               return 223;
17648                                                             }
17649                                                         }
17650                                                     }
17651                                                   else
17652                                                     {
17653                                                       if (((word >> 16) & 0x1) == 0)
17654                                                         {
17655                                                           /* 33222222222211111111110000000000
17656                                                              10987654321098765432109876543210
17657                                                              xx101110xx1xxxx0011010xxxxxxxxxx
17658                                                              uadalp.  */
17659                                                           return 217;
17660                                                         }
17661                                                       else
17662                                                         {
17663                                                           if (((word >> 30) & 0x1) == 0)
17664                                                             {
17665                                                               /* 33222222222211111111110000000000
17666                                                                  10987654321098765432109876543210
17667                                                                  x0101110xx1xxxx1011010xxxxxxxxxx
17668                                                                  fcvtxn.  */
17669                                                               return 228;
17670                                                             }
17671                                                           else
17672                                                             {
17673                                                               /* 33222222222211111111110000000000
17674                                                                  10987654321098765432109876543210
17675                                                                  x1101110xx1xxxx1011010xxxxxxxxxx
17676                                                                  fcvtxn2.  */
17677                                                               return 229;
17678                                                             }
17679                                                         }
17680                                                     }
17681                                                 }
17682                                             }
17683                                           else
17684                                             {
17685                                               if (((word >> 13) & 0x1) == 0)
17686                                                 {
17687                                                   if (((word >> 22) & 0x1) == 0)
17688                                                     {
17689                                                       /* 33222222222211111111110000000000
17690                                                          10987654321098765432109876543210
17691                                                          xx101110x01xxxxx0x0110xxxxxxxxxx
17692                                                          not.  */
17693                                                       return 242;
17694                                                     }
17695                                                   else
17696                                                     {
17697                                                       /* 33222222222211111111110000000000
17698                                                          10987654321098765432109876543210
17699                                                          xx101110x11xxxxx0x0110xxxxxxxxxx
17700                                                          rbit.  */
17701                                                       return 244;
17702                                                     }
17703                                                 }
17704                                               else
17705                                                 {
17706                                                   if (((word >> 14) & 0x1) == 0)
17707                                                     {
17708                                                       if (((word >> 16) & 0x1) == 0)
17709                                                         {
17710                                                           if (((word >> 20) & 0x1) == 0)
17711                                                             {
17712                                                               /* 33222222222211111111110000000000
17713                                                                  10987654321098765432109876543210
17714                                                                  xx101110xx10xxx0001110xxxxxxxxxx
17715                                                                  usqadd.  */
17716                                                               return 215;
17717                                                             }
17718                                                           else
17719                                                             {
17720                                                               /* 33222222222211111111110000000000
17721                                                                  10987654321098765432109876543210
17722                                                                  xx101110xx11xxx0001110xxxxxxxxxx
17723                                                                  uaddlv.  */
17724                                                               return 33;
17725                                                             }
17726                                                         }
17727                                                       else
17728                                                         {
17729                                                           if (((word >> 30) & 0x1) == 0)
17730                                                             {
17731                                                               /* 33222222222211111111110000000000
17732                                                                  10987654321098765432109876543210
17733                                                                  x0101110xx1xxxx1001110xxxxxxxxxx
17734                                                                  shll.  */
17735                                                               return 224;
17736                                                             }
17737                                                           else
17738                                                             {
17739                                                               /* 33222222222211111111110000000000
17740                                                                  10987654321098765432109876543210
17741                                                                  x1101110xx1xxxx1001110xxxxxxxxxx
17742                                                                  shll2.  */
17743                                                               return 225;
17744                                                             }
17745                                                         }
17746                                                     }
17747                                                   else
17748                                                     {
17749                                                       /* 33222222222211111111110000000000
17750                                                          10987654321098765432109876543210
17751                                                          xx101110xx1xxxxx011110xxxxxxxxxx
17752                                                          sqneg.  */
17753                                                       return 218;
17754                                                     }
17755                                                 }
17756                                             }
17757                                         }
17758                                     }
17759                                   else
17760                                     {
17761                                       if (((word >> 11) & 0x1) == 0)
17762                                         {
17763                                           if (((word >> 12) & 0x1) == 0)
17764                                             {
17765                                               if (((word >> 13) & 0x1) == 0)
17766                                                 {
17767                                                   if (((word >> 14) & 0x1) == 0)
17768                                                     {
17769                                                       /* 33222222222211111111110000000000
17770                                                          10987654321098765432109876543210
17771                                                          xx101110xx1xxxxx000001xxxxxxxxxx
17772                                                          uhadd.  */
17773                                                       return 320;
17774                                                     }
17775                                                   else
17776                                                     {
17777                                                       /* 33222222222211111111110000000000
17778                                                          10987654321098765432109876543210
17779                                                          xx101110xx1xxxxx010001xxxxxxxxxx
17780                                                          ushl.  */
17781                                                       return 327;
17782                                                     }
17783                                                 }
17784                                               else
17785                                                 {
17786                                                   if (((word >> 14) & 0x1) == 0)
17787                                                     {
17788                                                       /* 33222222222211111111110000000000
17789                                                          10987654321098765432109876543210
17790                                                          xx101110xx1xxxxx001001xxxxxxxxxx
17791                                                          uhsub.  */
17792                                                       return 323;
17793                                                     }
17794                                                   else
17795                                                     {
17796                                                       /* 33222222222211111111110000000000
17797                                                          10987654321098765432109876543210
17798                                                          xx101110xx1xxxxx011001xxxxxxxxxx
17799                                                          umax.  */
17800                                                       return 331;
17801                                                     }
17802                                                 }
17803                                             }
17804                                           else
17805                                             {
17806                                               if (((word >> 13) & 0x1) == 0)
17807                                                 {
17808                                                   if (((word >> 14) & 0x1) == 0)
17809                                                     {
17810                                                       /* 33222222222211111111110000000000
17811                                                          10987654321098765432109876543210
17812                                                          xx101110xx1xxxxx000101xxxxxxxxxx
17813                                                          urhadd.  */
17814                                                       return 322;
17815                                                     }
17816                                                   else
17817                                                     {
17818                                                       /* 33222222222211111111110000000000
17819                                                          10987654321098765432109876543210
17820                                                          xx101110xx1xxxxx010101xxxxxxxxxx
17821                                                          urshl.  */
17822                                                       return 329;
17823                                                     }
17824                                                 }
17825                                               else
17826                                                 {
17827                                                   if (((word >> 14) & 0x1) == 0)
17828                                                     {
17829                                                       /* 33222222222211111111110000000000
17830                                                          10987654321098765432109876543210
17831                                                          xx101110xx1xxxxx001101xxxxxxxxxx
17832                                                          cmhi.  */
17833                                                       return 325;
17834                                                     }
17835                                                   else
17836                                                     {
17837                                                       /* 33222222222211111111110000000000
17838                                                          10987654321098765432109876543210
17839                                                          xx101110xx1xxxxx011101xxxxxxxxxx
17840                                                          uabd.  */
17841                                                       return 333;
17842                                                     }
17843                                                 }
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                                                          xx101110xx1xxxxx000011xxxxxxxxxx
17857                                                          uqadd.  */
17858                                                       return 321;
17859                                                     }
17860                                                   else
17861                                                     {
17862                                                       /* 33222222222211111111110000000000
17863                                                          10987654321098765432109876543210
17864                                                          xx101110xx1xxxxx010011xxxxxxxxxx
17865                                                          uqshl.  */
17866                                                       return 328;
17867                                                     }
17868                                                 }
17869                                               else
17870                                                 {
17871                                                   if (((word >> 14) & 0x1) == 0)
17872                                                     {
17873                                                       /* 33222222222211111111110000000000
17874                                                          10987654321098765432109876543210
17875                                                          xx101110xx1xxxxx001011xxxxxxxxxx
17876                                                          uqsub.  */
17877                                                       return 324;
17878                                                     }
17879                                                   else
17880                                                     {
17881                                                       /* 33222222222211111111110000000000
17882                                                          10987654321098765432109876543210
17883                                                          xx101110xx1xxxxx011011xxxxxxxxxx
17884                                                          umin.  */
17885                                                       return 332;
17886                                                     }
17887                                                 }
17888                                             }
17889                                           else
17890                                             {
17891                                               if (((word >> 13) & 0x1) == 0)
17892                                                 {
17893                                                   if (((word >> 14) & 0x1) == 0)
17894                                                     {
17895                                                       if (((word >> 22) & 0x1) == 0)
17896                                                         {
17897                                                           if (((word >> 23) & 0x1) == 0)
17898                                                             {
17899                                                               /* 33222222222211111111110000000000
17900                                                                  10987654321098765432109876543210
17901                                                                  xx101110001xxxxx000111xxxxxxxxxx
17902                                                                  eor.  */
17903                                                               return 356;
17904                                                             }
17905                                                           else
17906                                                             {
17907                                                               /* 33222222222211111111110000000000
17908                                                                  10987654321098765432109876543210
17909                                                                  xx101110101xxxxx000111xxxxxxxxxx
17910                                                                  bit.  */
17911                                                               return 368;
17912                                                             }
17913                                                         }
17914                                                       else
17915                                                         {
17916                                                           if (((word >> 23) & 0x1) == 0)
17917                                                             {
17918                                                               /* 33222222222211111111110000000000
17919                                                                  10987654321098765432109876543210
17920                                                                  xx101110011xxxxx000111xxxxxxxxxx
17921                                                                  bsl.  */
17922                                                               return 357;
17923                                                             }
17924                                                           else
17925                                                             {
17926                                                               /* 33222222222211111111110000000000
17927                                                                  10987654321098765432109876543210
17928                                                                  xx101110111xxxxx000111xxxxxxxxxx
17929                                                                  bif.  */
17930                                                               return 369;
17931                                                             }
17932                                                         }
17933                                                     }
17934                                                   else
17935                                                     {
17936                                                       /* 33222222222211111111110000000000
17937                                                          10987654321098765432109876543210
17938                                                          xx101110xx1xxxxx010111xxxxxxxxxx
17939                                                          uqrshl.  */
17940                                                       return 330;
17941                                                     }
17942                                                 }
17943                                               else
17944                                                 {
17945                                                   if (((word >> 14) & 0x1) == 0)
17946                                                     {
17947                                                       /* 33222222222211111111110000000000
17948                                                          10987654321098765432109876543210
17949                                                          xx101110xx1xxxxx001111xxxxxxxxxx
17950                                                          cmhs.  */
17951                                                       return 326;
17952                                                     }
17953                                                   else
17954                                                     {
17955                                                       /* 33222222222211111111110000000000
17956                                                          10987654321098765432109876543210
17957                                                          xx101110xx1xxxxx011111xxxxxxxxxx
17958                                                          uaba.  */
17959                                                       return 334;
17960                                                     }
17961                                                 }
17962                                             }
17963                                         }
17964                                     }
17965                                 }
17966                             }
17967                           else
17968                             {
17969                               if (((word >> 10) & 0x1) == 0)
17970                                 {
17971                                   if (((word >> 11) & 0x1) == 0)
17972                                     {
17973                                       if (((word >> 12) & 0x1) == 0)
17974                                         {
17975                                           if (((word >> 13) & 0x1) == 0)
17976                                             {
17977                                               if (((word >> 14) & 0x1) == 0)
17978                                                 {
17979                                                   if (((word >> 29) & 0x1) == 0)
17980                                                     {
17981                                                       if (((word >> 30) & 0x1) == 0)
17982                                                         {
17983                                                           /* 33222222222211111111110000000000
17984                                                              10987654321098765432109876543210
17985                                                              x0001110xx1xxxxx100000xxxxxxxxxx
17986                                                              smlal.  */
17987                                                           return 60;
17988                                                         }
17989                                                       else
17990                                                         {
17991                                                           if (((word >> 31) & 0x1) == 0)
17992                                                             {
17993                                                               /* 33222222222211111111110000000000
17994                                                                  10987654321098765432109876543210
17995                                                                  01001110xx1xxxxx100000xxxxxxxxxx
17996                                                                  smlal2.  */
17997                                                               return 61;
17998                                                             }
17999                                                           else
18000                                                             {
18001                                                               /* 33222222222211111111110000000000
18002                                                                  10987654321098765432109876543210
18003                                                                  11001110xx1xxxxx100000xxxxxxxxxx
18004                                                                  sha512h.  */
18005                                                               return 2340;
18006                                                             }
18007                                                         }
18008                                                     }
18009                                                   else
18010                                                     {
18011                                                       if (((word >> 30) & 0x1) == 0)
18012                                                         {
18013                                                           /* 33222222222211111111110000000000
18014                                                              10987654321098765432109876543210
18015                                                              x0101110xx1xxxxx100000xxxxxxxxxx
18016                                                              umlal.  */
18017                                                           return 92;
18018                                                         }
18019                                                       else
18020                                                         {
18021                                                           /* 33222222222211111111110000000000
18022                                                              10987654321098765432109876543210
18023                                                              x1101110xx1xxxxx100000xxxxxxxxxx
18024                                                              umlal2.  */
18025                                                           return 93;
18026                                                         }
18027                                                     }
18028                                                 }
18029                                               else
18030                                                 {
18031                                                   if (((word >> 29) & 0x1) == 0)
18032                                                     {
18033                                                       if (((word >> 30) & 0x1) == 0)
18034                                                         {
18035                                                           /* 33222222222211111111110000000000
18036                                                              10987654321098765432109876543210
18037                                                              x0001110xx1xxxxx110000xxxxxxxxxx
18038                                                              smull.  */
18039                                                           return 68;
18040                                                         }
18041                                                       else
18042                                                         {
18043                                                           if (((word >> 31) & 0x1) == 0)
18044                                                             {
18045                                                               /* 33222222222211111111110000000000
18046                                                                  10987654321098765432109876543210
18047                                                                  01001110xx1xxxxx110000xxxxxxxxxx
18048                                                                  smull2.  */
18049                                                               return 69;
18050                                                             }
18051                                                           else
18052                                                             {
18053                                                               /* 33222222222211111111110000000000
18054                                                                  10987654321098765432109876543210
18055                                                                  11001110xx1xxxxx110000xxxxxxxxxx
18056                                                                  sm3partw1.  */
18057                                                               return 2353;
18058                                                             }
18059                                                         }
18060                                                     }
18061                                                   else
18062                                                     {
18063                                                       if (((word >> 30) & 0x1) == 0)
18064                                                         {
18065                                                           /* 33222222222211111111110000000000
18066                                                              10987654321098765432109876543210
18067                                                              x0101110xx1xxxxx110000xxxxxxxxxx
18068                                                              umull.  */
18069                                                           return 96;
18070                                                         }
18071                                                       else
18072                                                         {
18073                                                           /* 33222222222211111111110000000000
18074                                                              10987654321098765432109876543210
18075                                                              x1101110xx1xxxxx110000xxxxxxxxxx
18076                                                              umull2.  */
18077                                                           return 97;
18078                                                         }
18079                                                     }
18080                                                 }
18081                                             }
18082                                           else
18083                                             {
18084                                               if (((word >> 14) & 0x1) == 0)
18085                                                 {
18086                                                   if (((word >> 29) & 0x1) == 0)
18087                                                     {
18088                                                       if (((word >> 30) & 0x1) == 0)
18089                                                         {
18090                                                           /* 33222222222211111111110000000000
18091                                                              10987654321098765432109876543210
18092                                                              x0001110xx1xxxxx101000xxxxxxxxxx
18093                                                              smlsl.  */
18094                                                           return 64;
18095                                                         }
18096                                                       else
18097                                                         {
18098                                                           /* 33222222222211111111110000000000
18099                                                              10987654321098765432109876543210
18100                                                              x1001110xx1xxxxx101000xxxxxxxxxx
18101                                                              smlsl2.  */
18102                                                           return 65;
18103                                                         }
18104                                                     }
18105                                                   else
18106                                                     {
18107                                                       if (((word >> 30) & 0x1) == 0)
18108                                                         {
18109                                                           /* 33222222222211111111110000000000
18110                                                              10987654321098765432109876543210
18111                                                              x0101110xx1xxxxx101000xxxxxxxxxx
18112                                                              umlsl.  */
18113                                                           return 94;
18114                                                         }
18115                                                       else
18116                                                         {
18117                                                           /* 33222222222211111111110000000000
18118                                                              10987654321098765432109876543210
18119                                                              x1101110xx1xxxxx101000xxxxxxxxxx
18120                                                              umlsl2.  */
18121                                                           return 95;
18122                                                         }
18123                                                     }
18124                                                 }
18125                                               else
18126                                                 {
18127                                                   if (((word >> 22) & 0x1) == 0)
18128                                                     {
18129                                                       if (((word >> 30) & 0x1) == 0)
18130                                                         {
18131                                                           /* 33222222222211111111110000000000
18132                                                              10987654321098765432109876543210
18133                                                              x0x01110x01xxxxx111000xxxxxxxxxx
18134                                                              pmull.  */
18135                                                           return 72;
18136                                                         }
18137                                                       else
18138                                                         {
18139                                                           /* 33222222222211111111110000000000
18140                                                              10987654321098765432109876543210
18141                                                              x1x01110x01xxxxx111000xxxxxxxxxx
18142                                                              pmull2.  */
18143                                                           return 74;
18144                                                         }
18145                                                     }
18146                                                   else
18147                                                     {
18148                                                       if (((word >> 30) & 0x1) == 0)
18149                                                         {
18150                                                           /* 33222222222211111111110000000000
18151                                                              10987654321098765432109876543210
18152                                                              x0x01110x11xxxxx111000xxxxxxxxxx
18153                                                              pmull.  */
18154                                                           return 73;
18155                                                         }
18156                                                       else
18157                                                         {
18158                                                           /* 33222222222211111111110000000000
18159                                                              10987654321098765432109876543210
18160                                                              x1x01110x11xxxxx111000xxxxxxxxxx
18161                                                              pmull2.  */
18162                                                           return 75;
18163                                                         }
18164                                                     }
18165                                                 }
18166                                             }
18167                                         }
18168                                       else
18169                                         {
18170                                           if (((word >> 13) & 0x1) == 0)
18171                                             {
18172                                               if (((word >> 14) & 0x1) == 0)
18173                                                 {
18174                                                   if (((word >> 30) & 0x1) == 0)
18175                                                     {
18176                                                       /* 33222222222211111111110000000000
18177                                                          10987654321098765432109876543210
18178                                                          x0x01110xx1xxxxx100100xxxxxxxxxx
18179                                                          sqdmlal.  */
18180                                                       return 62;
18181                                                     }
18182                                                   else
18183                                                     {
18184                                                       /* 33222222222211111111110000000000
18185                                                          10987654321098765432109876543210
18186                                                          x1x01110xx1xxxxx100100xxxxxxxxxx
18187                                                          sqdmlal2.  */
18188                                                       return 63;
18189                                                     }
18190                                                 }
18191                                               else
18192                                                 {
18193                                                   if (((word >> 30) & 0x1) == 0)
18194                                                     {
18195                                                       /* 33222222222211111111110000000000
18196                                                          10987654321098765432109876543210
18197                                                          x0x01110xx1xxxxx110100xxxxxxxxxx
18198                                                          sqdmull.  */
18199                                                       return 70;
18200                                                     }
18201                                                   else
18202                                                     {
18203                                                       /* 33222222222211111111110000000000
18204                                                          10987654321098765432109876543210
18205                                                          x1x01110xx1xxxxx110100xxxxxxxxxx
18206                                                          sqdmull2.  */
18207                                                       return 71;
18208                                                     }
18209                                                 }
18210                                             }
18211                                           else
18212                                             {
18213                                               if (((word >> 30) & 0x1) == 0)
18214                                                 {
18215                                                   /* 33222222222211111111110000000000
18216                                                      10987654321098765432109876543210
18217                                                      x0x01110xx1xxxxx1x1100xxxxxxxxxx
18218                                                      sqdmlsl.  */
18219                                                   return 66;
18220                                                 }
18221                                               else
18222                                                 {
18223                                                   /* 33222222222211111111110000000000
18224                                                      10987654321098765432109876543210
18225                                                      x1x01110xx1xxxxx1x1100xxxxxxxxxx
18226                                                      sqdmlsl2.  */
18227                                                   return 67;
18228                                                 }
18229                                             }
18230                                         }
18231                                     }
18232                                   else
18233                                     {
18234                                       if (((word >> 12) & 0x1) == 0)
18235                                         {
18236                                           if (((word >> 13) & 0x1) == 0)
18237                                             {
18238                                               if (((word >> 14) & 0x1) == 0)
18239                                                 {
18240                                                   if (((word >> 29) & 0x1) == 0)
18241                                                     {
18242                                                       if (((word >> 31) & 0x1) == 0)
18243                                                         {
18244                                                           if (((word >> 16) & 0x1) == 0)
18245                                                             {
18246                                                               /* 33222222222211111111110000000000
18247                                                                  10987654321098765432109876543210
18248                                                                  0x001110xx1xxxx0100010xxxxxxxxxx
18249                                                                  cmgt.  */
18250                                                               return 170;
18251                                                             }
18252                                                           else
18253                                                             {
18254                                                               if (((word >> 19) & 0x1) == 0)
18255                                                                 {
18256                                                                   if (((word >> 23) & 0x1) == 0)
18257                                                                     {
18258                                                                       /* 33222222222211111111110000000000
18259                                                                          10987654321098765432109876543210
18260                                                                          0x0011100x1x0xx1100010xxxxxxxxxx
18261                                                                          frintn.  */
18262                                                                       return 182;
18263                                                                     }
18264                                                                   else
18265                                                                     {
18266                                                                       /* 33222222222211111111110000000000
18267                                                                          10987654321098765432109876543210
18268                                                                          0x0011101x1x0xx1100010xxxxxxxxxx
18269                                                                          frintp.  */
18270                                                                       return 202;
18271                                                                     }
18272                                                                 }
18273                                                               else
18274                                                                 {
18275                                                                   if (((word >> 23) & 0x1) == 0)
18276                                                                     {
18277                                                                       /* 33222222222211111111110000000000
18278                                                                          10987654321098765432109876543210
18279                                                                          0x0011100x1x1xx1100010xxxxxxxxxx
18280                                                                          frintn.  */
18281                                                                       return 183;
18282                                                                     }
18283                                                                   else
18284                                                                     {
18285                                                                       /* 33222222222211111111110000000000
18286                                                                          10987654321098765432109876543210
18287                                                                          0x0011101x1x1xx1100010xxxxxxxxxx
18288                                                                          frintp.  */
18289                                                                       return 203;
18290                                                                     }
18291                                                                 }
18292                                                             }
18293                                                         }
18294                                                       else
18295                                                         {
18296                                                           /* 33222222222211111111110000000000
18297                                                              10987654321098765432109876543210
18298                                                              1x001110xx1xxxxx100010xxxxxxxxxx
18299                                                              sha512su1.  */
18300                                                           return 2343;
18301                                                         }
18302                                                     }
18303                                                   else
18304                                                     {
18305                                                       if (((word >> 16) & 0x1) == 0)
18306                                                         {
18307                                                           /* 33222222222211111111110000000000
18308                                                              10987654321098765432109876543210
18309                                                              xx101110xx1xxxx0100010xxxxxxxxxx
18310                                                              cmge.  */
18311                                                           return 219;
18312                                                         }
18313                                                       else
18314                                                         {
18315                                                           if (((word >> 19) & 0x1) == 0)
18316                                                             {
18317                                                               /* 33222222222211111111110000000000
18318                                                                  10987654321098765432109876543210
18319                                                                  xx101110xx1x0xx1100010xxxxxxxxxx
18320                                                                  frinta.  */
18321                                                               return 230;
18322                                                             }
18323                                                           else
18324                                                             {
18325                                                               /* 33222222222211111111110000000000
18326                                                                  10987654321098765432109876543210
18327                                                                  xx101110xx1x1xx1100010xxxxxxxxxx
18328                                                                  frinta.  */
18329                                                               return 231;
18330                                                             }
18331                                                         }
18332                                                     }
18333                                                 }
18334                                               else
18335                                                 {
18336                                                   if (((word >> 23) & 0x1) == 0)
18337                                                     {
18338                                                       if (((word >> 29) & 0x1) == 0)
18339                                                         {
18340                                                           if (((word >> 31) & 0x1) == 0)
18341                                                             {
18342                                                               if (((word >> 16) & 0x1) == 0)
18343                                                                 {
18344                                                                   /* 33222222222211111111110000000000
18345                                                                      10987654321098765432109876543210
18346                                                                      0x0011100x1xxxx0110010xxxxxxxxxx
18347                                                                      fmaxnmv.  */
18348                                                                   return 37;
18349                                                                 }
18350                                                               else
18351                                                                 {
18352                                                                   if (((word >> 19) & 0x1) == 0)
18353                                                                     {
18354                                                                       /* 33222222222211111111110000000000
18355                                                                          10987654321098765432109876543210
18356                                                                          0x0011100x1x0xx1110010xxxxxxxxxx
18357                                                                          fcvtas.  */
18358                                                                       return 190;
18359                                                                     }
18360                                                                   else
18361                                                                     {
18362                                                                       /* 33222222222211111111110000000000
18363                                                                          10987654321098765432109876543210
18364                                                                          0x0011100x1x1xx1110010xxxxxxxxxx
18365                                                                          fcvtas.  */
18366                                                                       return 191;
18367                                                                     }
18368                                                                 }
18369                                                             }
18370                                                           else
18371                                                             {
18372                                                               /* 33222222222211111111110000000000
18373                                                                  10987654321098765432109876543210
18374                                                                  1x0011100x1xxxxx110010xxxxxxxxxx
18375                                                                  sm4ekey.  */
18376                                                               return 2356;
18377                                                             }
18378                                                         }
18379                                                       else
18380                                                         {
18381                                                           if (((word >> 16) & 0x1) == 0)
18382                                                             {
18383                                                               /* 33222222222211111111110000000000
18384                                                                  10987654321098765432109876543210
18385                                                                  xx1011100x1xxxx0110010xxxxxxxxxx
18386                                                                  fmaxnmv.  */
18387                                                               return 36;
18388                                                             }
18389                                                           else
18390                                                             {
18391                                                               if (((word >> 19) & 0x1) == 0)
18392                                                                 {
18393                                                                   /* 33222222222211111111110000000000
18394                                                                      10987654321098765432109876543210
18395                                                                      xx1011100x1x0xx1110010xxxxxxxxxx
18396                                                                      fcvtau.  */
18397                                                                   return 238;
18398                                                                 }
18399                                                               else
18400                                                                 {
18401                                                                   /* 33222222222211111111110000000000
18402                                                                      10987654321098765432109876543210
18403                                                                      xx1011100x1x1xx1110010xxxxxxxxxx
18404                                                                      fcvtau.  */
18405                                                                   return 239;
18406                                                                 }
18407                                                             }
18408                                                         }
18409                                                     }
18410                                                   else
18411                                                     {
18412                                                       if (((word >> 16) & 0x1) == 0)
18413                                                         {
18414                                                           if (((word >> 19) & 0x1) == 0)
18415                                                             {
18416                                                               if (((word >> 20) & 0x1) == 0)
18417                                                                 {
18418                                                                   if (((word >> 29) & 0x1) == 0)
18419                                                                     {
18420                                                                       /* 33222222222211111111110000000000
18421                                                                          10987654321098765432109876543210
18422                                                                          xx0011101x100xx0110010xxxxxxxxxx
18423                                                                          fcmgt.  */
18424                                                                       return 194;
18425                                                                     }
18426                                                                   else
18427                                                                     {
18428                                                                       /* 33222222222211111111110000000000
18429                                                                          10987654321098765432109876543210
18430                                                                          xx1011101x100xx0110010xxxxxxxxxx
18431                                                                          fcmge.  */
18432                                                                       return 245;
18433                                                                     }
18434                                                                 }
18435                                                               else
18436                                                                 {
18437                                                                   if (((word >> 29) & 0x1) == 0)
18438                                                                     {
18439                                                                       /* 33222222222211111111110000000000
18440                                                                          10987654321098765432109876543210
18441                                                                          xx0011101x110xx0110010xxxxxxxxxx
18442                                                                          fminnmv.  */
18443                                                                       return 41;
18444                                                                     }
18445                                                                   else
18446                                                                     {
18447                                                                       /* 33222222222211111111110000000000
18448                                                                          10987654321098765432109876543210
18449                                                                          xx1011101x110xx0110010xxxxxxxxxx
18450                                                                          fminnmv.  */
18451                                                                       return 40;
18452                                                                     }
18453                                                                 }
18454                                                             }
18455                                                           else
18456                                                             {
18457                                                               if (((word >> 29) & 0x1) == 0)
18458                                                                 {
18459                                                                   /* 33222222222211111111110000000000
18460                                                                      10987654321098765432109876543210
18461                                                                      xx0011101x1x1xx0110010xxxxxxxxxx
18462                                                                      fcmgt.  */
18463                                                                   return 195;
18464                                                                 }
18465                                                               else
18466                                                                 {
18467                                                                   /* 33222222222211111111110000000000
18468                                                                      10987654321098765432109876543210
18469                                                                      xx1011101x1x1xx0110010xxxxxxxxxx
18470                                                                      fcmge.  */
18471                                                                   return 246;
18472                                                                 }
18473                                                             }
18474                                                         }
18475                                                       else
18476                                                         {
18477                                                           if (((word >> 29) & 0x1) == 0)
18478                                                             {
18479                                                               /* 33222222222211111111110000000000
18480                                                                  10987654321098765432109876543210
18481                                                                  xx0011101x1xxxx1110010xxxxxxxxxx
18482                                                                  urecpe.  */
18483                                                               return 210;
18484                                                             }
18485                                                           else
18486                                                             {
18487                                                               /* 33222222222211111111110000000000
18488                                                                  10987654321098765432109876543210
18489                                                                  xx1011101x1xxxx1110010xxxxxxxxxx
18490                                                                  ursqrte.  */
18491                                                               return 257;
18492                                                             }
18493                                                         }
18494                                                     }
18495                                                 }
18496                                             }
18497                                           else
18498                                             {
18499                                               if (((word >> 14) & 0x1) == 0)
18500                                                 {
18501                                                   if (((word >> 16) & 0x1) == 0)
18502                                                     {
18503                                                       if (((word >> 20) & 0x1) == 0)
18504                                                         {
18505                                                           /* 33222222222211111111110000000000
18506                                                              10987654321098765432109876543210
18507                                                              xxx01110xx10xxx0101010xxxxxxxxxx
18508                                                              cmlt.  */
18509                                                           return 172;
18510                                                         }
18511                                                       else
18512                                                         {
18513                                                           if (((word >> 29) & 0x1) == 0)
18514                                                             {
18515                                                               /* 33222222222211111111110000000000
18516                                                                  10987654321098765432109876543210
18517                                                                  xx001110xx11xxx0101010xxxxxxxxxx
18518                                                                  smaxv.  */
18519                                                               return 30;
18520                                                             }
18521                                                           else
18522                                                             {
18523                                                               /* 33222222222211111111110000000000
18524                                                                  10987654321098765432109876543210
18525                                                                  xx101110xx11xxx0101010xxxxxxxxxx
18526                                                                  umaxv.  */
18527                                                               return 34;
18528                                                             }
18529                                                         }
18530                                                     }
18531                                                   else
18532                                                     {
18533                                                       if (((word >> 19) & 0x1) == 0)
18534                                                         {
18535                                                           if (((word >> 20) & 0x1) == 0)
18536                                                             {
18537                                                               if (((word >> 23) & 0x1) == 0)
18538                                                                 {
18539                                                                   if (((word >> 29) & 0x1) == 0)
18540                                                                     {
18541                                                                       /* 33222222222211111111110000000000
18542                                                                          10987654321098765432109876543210
18543                                                                          xx0011100x100xx1101010xxxxxxxxxx
18544                                                                          fcvtns.  */
18545                                                                       return 186;
18546                                                                     }
18547                                                                   else
18548                                                                     {
18549                                                                       /* 33222222222211111111110000000000
18550                                                                          10987654321098765432109876543210
18551                                                                          xx1011100x100xx1101010xxxxxxxxxx
18552                                                                          fcvtnu.  */
18553                                                                       return 234;
18554                                                                     }
18555                                                                 }
18556                                                               else
18557                                                                 {
18558                                                                   if (((word >> 29) & 0x1) == 0)
18559                                                                     {
18560                                                                       /* 33222222222211111111110000000000
18561                                                                          10987654321098765432109876543210
18562                                                                          xx0011101x100xx1101010xxxxxxxxxx
18563                                                                          fcvtps.  */
18564                                                                       return 206;
18565                                                                     }
18566                                                                   else
18567                                                                     {
18568                                                                       /* 33222222222211111111110000000000
18569                                                                          10987654321098765432109876543210
18570                                                                          xx1011101x100xx1101010xxxxxxxxxx
18571                                                                          fcvtpu.  */
18572                                                                       return 253;
18573                                                                     }
18574                                                                 }
18575                                                             }
18576                                                           else
18577                                                             {
18578                                                               if (((word >> 29) & 0x1) == 0)
18579                                                                 {
18580                                                                   /* 33222222222211111111110000000000
18581                                                                      10987654321098765432109876543210
18582                                                                      xx001110xx110xx1101010xxxxxxxxxx
18583                                                                      sminv.  */
18584                                                                   return 31;
18585                                                                 }
18586                                                               else
18587                                                                 {
18588                                                                   /* 33222222222211111111110000000000
18589                                                                      10987654321098765432109876543210
18590                                                                      xx101110xx110xx1101010xxxxxxxxxx
18591                                                                      uminv.  */
18592                                                                   return 35;
18593                                                                 }
18594                                                             }
18595                                                         }
18596                                                       else
18597                                                         {
18598                                                           if (((word >> 23) & 0x1) == 0)
18599                                                             {
18600                                                               if (((word >> 29) & 0x1) == 0)
18601                                                                 {
18602                                                                   /* 33222222222211111111110000000000
18603                                                                      10987654321098765432109876543210
18604                                                                      xx0011100x1x1xx1101010xxxxxxxxxx
18605                                                                      fcvtns.  */
18606                                                                   return 187;
18607                                                                 }
18608                                                               else
18609                                                                 {
18610                                                                   /* 33222222222211111111110000000000
18611                                                                      10987654321098765432109876543210
18612                                                                      xx1011100x1x1xx1101010xxxxxxxxxx
18613                                                                      fcvtnu.  */
18614                                                                   return 235;
18615                                                                 }
18616                                                             }
18617                                                           else
18618                                                             {
18619                                                               if (((word >> 29) & 0x1) == 0)
18620                                                                 {
18621                                                                   /* 33222222222211111111110000000000
18622                                                                      10987654321098765432109876543210
18623                                                                      xx0011101x1x1xx1101010xxxxxxxxxx
18624                                                                      fcvtps.  */
18625                                                                   return 207;
18626                                                                 }
18627                                                               else
18628                                                                 {
18629                                                                   /* 33222222222211111111110000000000
18630                                                                      10987654321098765432109876543210
18631                                                                      xx1011101x1x1xx1101010xxxxxxxxxx
18632                                                                      fcvtpu.  */
18633                                                                   return 254;
18634                                                                 }
18635                                                             }
18636                                                         }
18637                                                     }
18638                                                 }
18639                                               else
18640                                                 {
18641                                                   if (((word >> 16) & 0x1) == 0)
18642                                                     {
18643                                                       if (((word >> 19) & 0x1) == 0)
18644                                                         {
18645                                                           /* 33222222222211111111110000000000
18646                                                              10987654321098765432109876543210
18647                                                              xxx01110xx1x0xx0111010xxxxxxxxxx
18648                                                              fcmlt.  */
18649                                                           return 198;
18650                                                         }
18651                                                       else
18652                                                         {
18653                                                           /* 33222222222211111111110000000000
18654                                                              10987654321098765432109876543210
18655                                                              xxx01110xx1x1xx0111010xxxxxxxxxx
18656                                                              fcmlt.  */
18657                                                           return 199;
18658                                                         }
18659                                                     }
18660                                                   else
18661                                                     {
18662                                                       if (((word >> 29) & 0x1) == 0)
18663                                                         {
18664                                                           /* 33222222222211111111110000000000
18665                                                              10987654321098765432109876543210
18666                                                              xx001110xx1xxxx1111010xxxxxxxxxx
18667                                                              frint32z.  */
18668                                                           return 158;
18669                                                         }
18670                                                       else
18671                                                         {
18672                                                           /* 33222222222211111111110000000000
18673                                                              10987654321098765432109876543210
18674                                                              xx101110xx1xxxx1111010xxxxxxxxxx
18675                                                              frint32x.  */
18676                                                           return 159;
18677                                                         }
18678                                                     }
18679                                                 }
18680                                             }
18681                                         }
18682                                       else
18683                                         {
18684                                           if (((word >> 13) & 0x1) == 0)
18685                                             {
18686                                               if (((word >> 14) & 0x1) == 0)
18687                                                 {
18688                                                   if (((word >> 16) & 0x1) == 0)
18689                                                     {
18690                                                       if (((word >> 29) & 0x1) == 0)
18691                                                         {
18692                                                           /* 33222222222211111111110000000000
18693                                                              10987654321098765432109876543210
18694                                                              xx001110xx1xxxx0100110xxxxxxxxxx
18695                                                              cmeq.  */
18696                                                           return 171;
18697                                                         }
18698                                                       else
18699                                                         {
18700                                                           /* 33222222222211111111110000000000
18701                                                              10987654321098765432109876543210
18702                                                              xx101110xx1xxxx0100110xxxxxxxxxx
18703                                                              cmle.  */
18704                                                           return 220;
18705                                                         }
18706                                                     }
18707                                                   else
18708                                                     {
18709                                                       if (((word >> 19) & 0x1) == 0)
18710                                                         {
18711                                                           if (((word >> 23) & 0x1) == 0)
18712                                                             {
18713                                                               if (((word >> 29) & 0x1) == 0)
18714                                                                 {
18715                                                                   /* 33222222222211111111110000000000
18716                                                                      10987654321098765432109876543210
18717                                                                      xx0011100x1x0xx1100110xxxxxxxxxx
18718                                                                      frintm.  */
18719                                                                   return 184;
18720                                                                 }
18721                                                               else
18722                                                                 {
18723                                                                   /* 33222222222211111111110000000000
18724                                                                      10987654321098765432109876543210
18725                                                                      xx1011100x1x0xx1100110xxxxxxxxxx
18726                                                                      frintx.  */
18727                                                                   return 232;
18728                                                                 }
18729                                                             }
18730                                                           else
18731                                                             {
18732                                                               if (((word >> 29) & 0x1) == 0)
18733                                                                 {
18734                                                                   /* 33222222222211111111110000000000
18735                                                                      10987654321098765432109876543210
18736                                                                      xx0011101x1x0xx1100110xxxxxxxxxx
18737                                                                      frintz.  */
18738                                                                   return 204;
18739                                                                 }
18740                                                               else
18741                                                                 {
18742                                                                   /* 33222222222211111111110000000000
18743                                                                      10987654321098765432109876543210
18744                                                                      xx1011101x1x0xx1100110xxxxxxxxxx
18745                                                                      frinti.  */
18746                                                                   return 251;
18747                                                                 }
18748                                                             }
18749                                                         }
18750                                                       else
18751                                                         {
18752                                                           if (((word >> 23) & 0x1) == 0)
18753                                                             {
18754                                                               if (((word >> 29) & 0x1) == 0)
18755                                                                 {
18756                                                                   /* 33222222222211111111110000000000
18757                                                                      10987654321098765432109876543210
18758                                                                      xx0011100x1x1xx1100110xxxxxxxxxx
18759                                                                      frintm.  */
18760                                                                   return 185;
18761                                                                 }
18762                                                               else
18763                                                                 {
18764                                                                   /* 33222222222211111111110000000000
18765                                                                      10987654321098765432109876543210
18766                                                                      xx1011100x1x1xx1100110xxxxxxxxxx
18767                                                                      frintx.  */
18768                                                                   return 233;
18769                                                                 }
18770                                                             }
18771                                                           else
18772                                                             {
18773                                                               if (((word >> 29) & 0x1) == 0)
18774                                                                 {
18775                                                                   /* 33222222222211111111110000000000
18776                                                                      10987654321098765432109876543210
18777                                                                      xx0011101x1x1xx1100110xxxxxxxxxx
18778                                                                      frintz.  */
18779                                                                   return 205;
18780                                                                 }
18781                                                               else
18782                                                                 {
18783                                                                   /* 33222222222211111111110000000000
18784                                                                      10987654321098765432109876543210
18785                                                                      xx1011101x1x1xx1100110xxxxxxxxxx
18786                                                                      frinti.  */
18787                                                                   return 252;
18788                                                                 }
18789                                                             }
18790                                                         }
18791                                                     }
18792                                                 }
18793                                               else
18794                                                 {
18795                                                   if (((word >> 16) & 0x1) == 0)
18796                                                     {
18797                                                       if (((word >> 19) & 0x1) == 0)
18798                                                         {
18799                                                           if (((word >> 29) & 0x1) == 0)
18800                                                             {
18801                                                               /* 33222222222211111111110000000000
18802                                                                  10987654321098765432109876543210
18803                                                                  xx001110xx1x0xx0110110xxxxxxxxxx
18804                                                                  fcmeq.  */
18805                                                               return 196;
18806                                                             }
18807                                                           else
18808                                                             {
18809                                                               /* 33222222222211111111110000000000
18810                                                                  10987654321098765432109876543210
18811                                                                  xx101110xx1x0xx0110110xxxxxxxxxx
18812                                                                  fcmle.  */
18813                                                               return 247;
18814                                                             }
18815                                                         }
18816                                                       else
18817                                                         {
18818                                                           if (((word >> 29) & 0x1) == 0)
18819                                                             {
18820                                                               /* 33222222222211111111110000000000
18821                                                                  10987654321098765432109876543210
18822                                                                  xx001110xx1x1xx0110110xxxxxxxxxx
18823                                                                  fcmeq.  */
18824                                                               return 197;
18825                                                             }
18826                                                           else
18827                                                             {
18828                                                               /* 33222222222211111111110000000000
18829                                                                  10987654321098765432109876543210
18830                                                                  xx101110xx1x1xx0110110xxxxxxxxxx
18831                                                                  fcmle.  */
18832                                                               return 248;
18833                                                             }
18834                                                         }
18835                                                     }
18836                                                   else
18837                                                     {
18838                                                       if (((word >> 19) & 0x1) == 0)
18839                                                         {
18840                                                           if (((word >> 23) & 0x1) == 0)
18841                                                             {
18842                                                               if (((word >> 29) & 0x1) == 0)
18843                                                                 {
18844                                                                   /* 33222222222211111111110000000000
18845                                                                      10987654321098765432109876543210
18846                                                                      xx0011100x1x0xx1110110xxxxxxxxxx
18847                                                                      scvtf.  */
18848                                                                   return 192;
18849                                                                 }
18850                                                               else
18851                                                                 {
18852                                                                   /* 33222222222211111111110000000000
18853                                                                      10987654321098765432109876543210
18854                                                                      xx1011100x1x0xx1110110xxxxxxxxxx
18855                                                                      ucvtf.  */
18856                                                                   return 240;
18857                                                                 }
18858                                                             }
18859                                                           else
18860                                                             {
18861                                                               if (((word >> 29) & 0x1) == 0)
18862                                                                 {
18863                                                                   /* 33222222222211111111110000000000
18864                                                                      10987654321098765432109876543210
18865                                                                      xx0011101x1x0xx1110110xxxxxxxxxx
18866                                                                      frecpe.  */
18867                                                                   return 211;
18868                                                                 }
18869                                                               else
18870                                                                 {
18871                                                                   /* 33222222222211111111110000000000
18872                                                                      10987654321098765432109876543210
18873                                                                      xx1011101x1x0xx1110110xxxxxxxxxx
18874                                                                      frsqrte.  */
18875                                                                   return 258;
18876                                                                 }
18877                                                             }
18878                                                         }
18879                                                       else
18880                                                         {
18881                                                           if (((word >> 23) & 0x1) == 0)
18882                                                             {
18883                                                               if (((word >> 29) & 0x1) == 0)
18884                                                                 {
18885                                                                   /* 33222222222211111111110000000000
18886                                                                      10987654321098765432109876543210
18887                                                                      xx0011100x1x1xx1110110xxxxxxxxxx
18888                                                                      scvtf.  */
18889                                                                   return 193;
18890                                                                 }
18891                                                               else
18892                                                                 {
18893                                                                   /* 33222222222211111111110000000000
18894                                                                      10987654321098765432109876543210
18895                                                                      xx1011100x1x1xx1110110xxxxxxxxxx
18896                                                                      ucvtf.  */
18897                                                                   return 241;
18898                                                                 }
18899                                                             }
18900                                                           else
18901                                                             {
18902                                                               if (((word >> 29) & 0x1) == 0)
18903                                                                 {
18904                                                                   /* 33222222222211111111110000000000
18905                                                                      10987654321098765432109876543210
18906                                                                      xx0011101x1x1xx1110110xxxxxxxxxx
18907                                                                      frecpe.  */
18908                                                                   return 212;
18909                                                                 }
18910                                                               else
18911                                                                 {
18912                                                                   /* 33222222222211111111110000000000
18913                                                                      10987654321098765432109876543210
18914                                                                      xx1011101x1x1xx1110110xxxxxxxxxx
18915                                                                      frsqrte.  */
18916                                                                   return 259;
18917                                                                 }
18918                                                             }
18919                                                         }
18920                                                     }
18921                                                 }
18922                                             }
18923                                           else
18924                                             {
18925                                               if (((word >> 14) & 0x1) == 0)
18926                                                 {
18927                                                   if (((word >> 16) & 0x1) == 0)
18928                                                     {
18929                                                       if (((word >> 29) & 0x1) == 0)
18930                                                         {
18931                                                           /* 33222222222211111111110000000000
18932                                                              10987654321098765432109876543210
18933                                                              xx001110xx1xxxx0101110xxxxxxxxxx
18934                                                              abs.  */
18935                                                           return 173;
18936                                                         }
18937                                                       else
18938                                                         {
18939                                                           /* 33222222222211111111110000000000
18940                                                              10987654321098765432109876543210
18941                                                              xx101110xx1xxxx0101110xxxxxxxxxx
18942                                                              neg.  */
18943                                                           return 221;
18944                                                         }
18945                                                     }
18946                                                   else
18947                                                     {
18948                                                       if (((word >> 19) & 0x1) == 0)
18949                                                         {
18950                                                           if (((word >> 20) & 0x1) == 0)
18951                                                             {
18952                                                               if (((word >> 23) & 0x1) == 0)
18953                                                                 {
18954                                                                   if (((word >> 29) & 0x1) == 0)
18955                                                                     {
18956                                                                       /* 33222222222211111111110000000000
18957                                                                          10987654321098765432109876543210
18958                                                                          xx0011100x100xx1101110xxxxxxxxxx
18959                                                                          fcvtms.  */
18960                                                                       return 188;
18961                                                                     }
18962                                                                   else
18963                                                                     {
18964                                                                       /* 33222222222211111111110000000000
18965                                                                          10987654321098765432109876543210
18966                                                                          xx1011100x100xx1101110xxxxxxxxxx
18967                                                                          fcvtmu.  */
18968                                                                       return 236;
18969                                                                     }
18970                                                                 }
18971                                                               else
18972                                                                 {
18973                                                                   if (((word >> 29) & 0x1) == 0)
18974                                                                     {
18975                                                                       /* 33222222222211111111110000000000
18976                                                                          10987654321098765432109876543210
18977                                                                          xx0011101x100xx1101110xxxxxxxxxx
18978                                                                          fcvtzs.  */
18979                                                                       return 208;
18980                                                                     }
18981                                                                   else
18982                                                                     {
18983                                                                       /* 33222222222211111111110000000000
18984                                                                          10987654321098765432109876543210
18985                                                                          xx1011101x100xx1101110xxxxxxxxxx
18986                                                                          fcvtzu.  */
18987                                                                       return 255;
18988                                                                     }
18989                                                                 }
18990                                                             }
18991                                                           else
18992                                                             {
18993                                                               /* 33222222222211111111110000000000
18994                                                                  10987654321098765432109876543210
18995                                                                  xxx01110xx110xx1101110xxxxxxxxxx
18996                                                                  addv.  */
18997                                                               return 32;
18998                                                             }
18999                                                         }
19000                                                       else
19001                                                         {
19002                                                           if (((word >> 23) & 0x1) == 0)
19003                                                             {
19004                                                               if (((word >> 29) & 0x1) == 0)
19005                                                                 {
19006                                                                   /* 33222222222211111111110000000000
19007                                                                      10987654321098765432109876543210
19008                                                                      xx0011100x1x1xx1101110xxxxxxxxxx
19009                                                                      fcvtms.  */
19010                                                                   return 189;
19011                                                                 }
19012                                                               else
19013                                                                 {
19014                                                                   /* 33222222222211111111110000000000
19015                                                                      10987654321098765432109876543210
19016                                                                      xx1011100x1x1xx1101110xxxxxxxxxx
19017                                                                      fcvtmu.  */
19018                                                                   return 237;
19019                                                                 }
19020                                                             }
19021                                                           else
19022                                                             {
19023                                                               if (((word >> 29) & 0x1) == 0)
19024                                                                 {
19025                                                                   /* 33222222222211111111110000000000
19026                                                                      10987654321098765432109876543210
19027                                                                      xx0011101x1x1xx1101110xxxxxxxxxx
19028                                                                      fcvtzs.  */
19029                                                                   return 209;
19030                                                                 }
19031                                                               else
19032                                                                 {
19033                                                                   /* 33222222222211111111110000000000
19034                                                                      10987654321098765432109876543210
19035                                                                      xx1011101x1x1xx1101110xxxxxxxxxx
19036                                                                      fcvtzu.  */
19037                                                                   return 256;
19038                                                                 }
19039                                                             }
19040                                                         }
19041                                                     }
19042                                                 }
19043                                               else
19044                                                 {
19045                                                   if (((word >> 16) & 0x1) == 0)
19046                                                     {
19047                                                       if (((word >> 19) & 0x1) == 0)
19048                                                         {
19049                                                           if (((word >> 20) & 0x1) == 0)
19050                                                             {
19051                                                               if (((word >> 29) & 0x1) == 0)
19052                                                                 {
19053                                                                   /* 33222222222211111111110000000000
19054                                                                      10987654321098765432109876543210
19055                                                                      xx001110xx100xx0111110xxxxxxxxxx
19056                                                                      fabs.  */
19057                                                                   return 200;
19058                                                                 }
19059                                                               else
19060                                                                 {
19061                                                                   /* 33222222222211111111110000000000
19062                                                                      10987654321098765432109876543210
19063                                                                      xx101110xx100xx0111110xxxxxxxxxx
19064                                                                      fneg.  */
19065                                                                   return 249;
19066                                                                 }
19067                                                             }
19068                                                           else
19069                                                             {
19070                                                               if (((word >> 23) & 0x1) == 0)
19071                                                                 {
19072                                                                   if (((word >> 29) & 0x1) == 0)
19073                                                                     {
19074                                                                       /* 33222222222211111111110000000000
19075                                                                          10987654321098765432109876543210
19076                                                                          xx0011100x110xx0111110xxxxxxxxxx
19077                                                                          fmaxv.  */
19078                                                                       return 39;
19079                                                                     }
19080                                                                   else
19081                                                                     {
19082                                                                       /* 33222222222211111111110000000000
19083                                                                          10987654321098765432109876543210
19084                                                                          xx1011100x110xx0111110xxxxxxxxxx
19085                                                                          fmaxv.  */
19086                                                                       return 38;
19087                                                                     }
19088                                                                 }
19089                                                               else
19090                                                                 {
19091                                                                   if (((word >> 29) & 0x1) == 0)
19092                                                                     {
19093                                                                       /* 33222222222211111111110000000000
19094                                                                          10987654321098765432109876543210
19095                                                                          xx0011101x110xx0111110xxxxxxxxxx
19096                                                                          fminv.  */
19097                                                                       return 43;
19098                                                                     }
19099                                                                   else
19100                                                                     {
19101                                                                       /* 33222222222211111111110000000000
19102                                                                          10987654321098765432109876543210
19103                                                                          xx1011101x110xx0111110xxxxxxxxxx
19104                                                                          fminv.  */
19105                                                                       return 42;
19106                                                                     }
19107                                                                 }
19108                                                             }
19109                                                         }
19110                                                       else
19111                                                         {
19112                                                           if (((word >> 29) & 0x1) == 0)
19113                                                             {
19114                                                               /* 33222222222211111111110000000000
19115                                                                  10987654321098765432109876543210
19116                                                                  xx001110xx1x1xx0111110xxxxxxxxxx
19117                                                                  fabs.  */
19118                                                               return 201;
19119                                                             }
19120                                                           else
19121                                                             {
19122                                                               /* 33222222222211111111110000000000
19123                                                                  10987654321098765432109876543210
19124                                                                  xx101110xx1x1xx0111110xxxxxxxxxx
19125                                                                  fneg.  */
19126                                                               return 250;
19127                                                             }
19128                                                         }
19129                                                     }
19130                                                   else
19131                                                     {
19132                                                       if (((word >> 19) & 0x1) == 0)
19133                                                         {
19134                                                           if (((word >> 23) & 0x1) == 0)
19135                                                             {
19136                                                               if (((word >> 29) & 0x1) == 0)
19137                                                                 {
19138                                                                   /* 33222222222211111111110000000000
19139                                                                      10987654321098765432109876543210
19140                                                                      xx0011100x1x0xx1111110xxxxxxxxxx
19141                                                                      frint64z.  */
19142                                                                   return 160;
19143                                                                 }
19144                                                               else
19145                                                                 {
19146                                                                   /* 33222222222211111111110000000000
19147                                                                      10987654321098765432109876543210
19148                                                                      xx1011100x1x0xx1111110xxxxxxxxxx
19149                                                                      frint64x.  */
19150                                                                   return 161;
19151                                                                 }
19152                                                             }
19153                                                           else
19154                                                             {
19155                                                               /* 33222222222211111111110000000000
19156                                                                  10987654321098765432109876543210
19157                                                                  xxx011101x1x0xx1111110xxxxxxxxxx
19158                                                                  fsqrt.  */
19159                                                               return 260;
19160                                                             }
19161                                                         }
19162                                                       else
19163                                                         {
19164                                                           /* 33222222222211111111110000000000
19165                                                              10987654321098765432109876543210
19166                                                              xxx01110xx1x1xx1111110xxxxxxxxxx
19167                                                              fsqrt.  */
19168                                                           return 261;
19169                                                         }
19170                                                     }
19171                                                 }
19172                                             }
19173                                         }
19174                                     }
19175                                 }
19176                               else
19177                                 {
19178                                   if (((word >> 11) & 0x1) == 0)
19179                                     {
19180                                       if (((word >> 12) & 0x1) == 0)
19181                                         {
19182                                           if (((word >> 13) & 0x1) == 0)
19183                                             {
19184                                               if (((word >> 14) & 0x1) == 0)
19185                                                 {
19186                                                   if (((word >> 29) & 0x1) == 0)
19187                                                     {
19188                                                       if (((word >> 31) & 0x1) == 0)
19189                                                         {
19190                                                           /* 33222222222211111111110000000000
19191                                                              10987654321098765432109876543210
19192                                                              0x001110xx1xxxxx100001xxxxxxxxxx
19193                                                              add.  */
19194                                                           return 283;
19195                                                         }
19196                                                       else
19197                                                         {
19198                                                           /* 33222222222211111111110000000000
19199                                                              10987654321098765432109876543210
19200                                                              1x001110xx1xxxxx100001xxxxxxxxxx
19201                                                              sha512h2.  */
19202                                                           return 2341;
19203                                                         }
19204                                                     }
19205                                                   else
19206                                                     {
19207                                                       /* 33222222222211111111110000000000
19208                                                          10987654321098765432109876543210
19209                                                          xx101110xx1xxxxx100001xxxxxxxxxx
19210                                                          sub.  */
19211                                                       return 335;
19212                                                     }
19213                                                 }
19214                                               else
19215                                                 {
19216                                                   if (((word >> 23) & 0x1) == 0)
19217                                                     {
19218                                                       if (((word >> 29) & 0x1) == 0)
19219                                                         {
19220                                                           if (((word >> 31) & 0x1) == 0)
19221                                                             {
19222                                                               /* 33222222222211111111110000000000
19223                                                                  10987654321098765432109876543210
19224                                                                  0x0011100x1xxxxx110001xxxxxxxxxx
19225                                                                  fmaxnm.  */
19226                                                               return 291;
19227                                                             }
19228                                                           else
19229                                                             {
19230                                                               /* 33222222222211111111110000000000
19231                                                                  10987654321098765432109876543210
19232                                                                  1x0011100x1xxxxx110001xxxxxxxxxx
19233                                                                  sm3partw2.  */
19234                                                               return 2354;
19235                                                             }
19236                                                         }
19237                                                       else
19238                                                         {
19239                                                           /* 33222222222211111111110000000000
19240                                                              10987654321098765432109876543210
19241                                                              xx1011100x1xxxxx110001xxxxxxxxxx
19242                                                              fmaxnmp.  */
19243                                                           return 342;
19244                                                         }
19245                                                     }
19246                                                   else
19247                                                     {
19248                                                       if (((word >> 29) & 0x1) == 0)
19249                                                         {
19250                                                           /* 33222222222211111111110000000000
19251                                                              10987654321098765432109876543210
19252                                                              xx0011101x1xxxxx110001xxxxxxxxxx
19253                                                              fminnm.  */
19254                                                           return 307;
19255                                                         }
19256                                                       else
19257                                                         {
19258                                                           /* 33222222222211111111110000000000
19259                                                              10987654321098765432109876543210
19260                                                              xx1011101x1xxxxx110001xxxxxxxxxx
19261                                                              fminnmp.  */
19262                                                           return 358;
19263                                                         }
19264                                                     }
19265                                                 }
19266                                             }
19267                                           else
19268                                             {
19269                                               if (((word >> 14) & 0x1) == 0)
19270                                                 {
19271                                                   if (((word >> 29) & 0x1) == 0)
19272                                                     {
19273                                                       /* 33222222222211111111110000000000
19274                                                          10987654321098765432109876543210
19275                                                          xx001110xx1xxxxx101001xxxxxxxxxx
19276                                                          smaxp.  */
19277                                                       return 287;
19278                                                     }
19279                                                   else
19280                                                     {
19281                                                       /* 33222222222211111111110000000000
19282                                                          10987654321098765432109876543210
19283                                                          xx101110xx1xxxxx101001xxxxxxxxxx
19284                                                          umaxp.  */
19285                                                       return 339;
19286                                                     }
19287                                                 }
19288                                               else
19289                                                 {
19290                                                   if (((word >> 23) & 0x1) == 0)
19291                                                     {
19292                                                       if (((word >> 29) & 0x1) == 0)
19293                                                         {
19294                                                           /* 33222222222211111111110000000000
19295                                                              10987654321098765432109876543210
19296                                                              xx0011100x1xxxxx111001xxxxxxxxxx
19297                                                              fcmeq.  */
19298                                                           return 299;
19299                                                         }
19300                                                       else
19301                                                         {
19302                                                           /* 33222222222211111111110000000000
19303                                                              10987654321098765432109876543210
19304                                                              xx1011100x1xxxxx111001xxxxxxxxxx
19305                                                              fcmge.  */
19306                                                           return 348;
19307                                                         }
19308                                                     }
19309                                                   else
19310                                                     {
19311                                                       /* 33222222222211111111110000000000
19312                                                          10987654321098765432109876543210
19313                                                          xxx011101x1xxxxx111001xxxxxxxxxx
19314                                                          fcmgt.  */
19315                                                       return 362;
19316                                                     }
19317                                                 }
19318                                             }
19319                                         }
19320                                       else
19321                                         {
19322                                           if (((word >> 13) & 0x1) == 0)
19323                                             {
19324                                               if (((word >> 14) & 0x1) == 0)
19325                                                 {
19326                                                   if (((word >> 29) & 0x1) == 0)
19327                                                     {
19328                                                       /* 33222222222211111111110000000000
19329                                                          10987654321098765432109876543210
19330                                                          xx001110xx1xxxxx100101xxxxxxxxxx
19331                                                          mla.  */
19332                                                       return 285;
19333                                                     }
19334                                                   else
19335                                                     {
19336                                                       /* 33222222222211111111110000000000
19337                                                          10987654321098765432109876543210
19338                                                          xx101110xx1xxxxx100101xxxxxxxxxx
19339                                                          mls.  */
19340                                                       return 337;
19341                                                     }
19342                                                 }
19343                                               else
19344                                                 {
19345                                                   if (((word >> 23) & 0x1) == 0)
19346                                                     {
19347                                                       if (((word >> 29) & 0x1) == 0)
19348                                                         {
19349                                                           /* 33222222222211111111110000000000
19350                                                              10987654321098765432109876543210
19351                                                              xx0011100x1xxxxx110101xxxxxxxxxx
19352                                                              fadd.  */
19353                                                           return 295;
19354                                                         }
19355                                                       else
19356                                                         {
19357                                                           /* 33222222222211111111110000000000
19358                                                              10987654321098765432109876543210
19359                                                              xx1011100x1xxxxx110101xxxxxxxxxx
19360                                                              faddp.  */
19361                                                           return 344;
19362                                                         }
19363                                                     }
19364                                                   else
19365                                                     {
19366                                                       if (((word >> 29) & 0x1) == 0)
19367                                                         {
19368                                                           /* 33222222222211111111110000000000
19369                                                              10987654321098765432109876543210
19370                                                              xx0011101x1xxxxx110101xxxxxxxxxx
19371                                                              fsub.  */
19372                                                           return 311;
19373                                                         }
19374                                                       else
19375                                                         {
19376                                                           /* 33222222222211111111110000000000
19377                                                              10987654321098765432109876543210
19378                                                              xx1011101x1xxxxx110101xxxxxxxxxx
19379                                                              fabd.  */
19380                                                           return 360;
19381                                                         }
19382                                                     }
19383                                                 }
19384                                             }
19385                                           else
19386                                             {
19387                                               if (((word >> 14) & 0x1) == 0)
19388                                                 {
19389                                                   if (((word >> 29) & 0x1) == 0)
19390                                                     {
19391                                                       /* 33222222222211111111110000000000
19392                                                          10987654321098765432109876543210
19393                                                          xx001110xx1xxxxx101101xxxxxxxxxx
19394                                                          sqdmulh.  */
19395                                                       return 289;
19396                                                     }
19397                                                   else
19398                                                     {
19399                                                       /* 33222222222211111111110000000000
19400                                                          10987654321098765432109876543210
19401                                                          xx101110xx1xxxxx101101xxxxxxxxxx
19402                                                          sqrdmulh.  */
19403                                                       return 341;
19404                                                     }
19405                                                 }
19406                                               else
19407                                                 {
19408                                                   if (((word >> 23) & 0x1) == 0)
19409                                                     {
19410                                                       if (((word >> 29) & 0x1) == 0)
19411                                                         {
19412                                                           /* 33222222222211111111110000000000
19413                                                              10987654321098765432109876543210
19414                                                              xx0011100x1xxxxx111101xxxxxxxxxx
19415                                                              fmax.  */
19416                                                           return 301;
19417                                                         }
19418                                                       else
19419                                                         {
19420                                                           /* 33222222222211111111110000000000
19421                                                              10987654321098765432109876543210
19422                                                              xx1011100x1xxxxx111101xxxxxxxxxx
19423                                                              fmaxp.  */
19424                                                           return 352;
19425                                                         }
19426                                                     }
19427                                                   else
19428                                                     {
19429                                                       if (((word >> 29) & 0x1) == 0)
19430                                                         {
19431                                                           /* 33222222222211111111110000000000
19432                                                              10987654321098765432109876543210
19433                                                              xx0011101x1xxxxx111101xxxxxxxxxx
19434                                                              fmin.  */
19435                                                           return 313;
19436                                                         }
19437                                                       else
19438                                                         {
19439                                                           /* 33222222222211111111110000000000
19440                                                              10987654321098765432109876543210
19441                                                              xx1011101x1xxxxx111101xxxxxxxxxx
19442                                                              fminp.  */
19443                                                           return 366;
19444                                                         }
19445                                                     }
19446                                                 }
19447                                             }
19448                                         }
19449                                     }
19450                                   else
19451                                     {
19452                                       if (((word >> 12) & 0x1) == 0)
19453                                         {
19454                                           if (((word >> 13) & 0x1) == 0)
19455                                             {
19456                                               if (((word >> 14) & 0x1) == 0)
19457                                                 {
19458                                                   if (((word >> 29) & 0x1) == 0)
19459                                                     {
19460                                                       if (((word >> 31) & 0x1) == 0)
19461                                                         {
19462                                                           /* 33222222222211111111110000000000
19463                                                              10987654321098765432109876543210
19464                                                              0x001110xx1xxxxx100011xxxxxxxxxx
19465                                                              cmtst.  */
19466                                                           return 284;
19467                                                         }
19468                                                       else
19469                                                         {
19470                                                           /* 33222222222211111111110000000000
19471                                                              10987654321098765432109876543210
19472                                                              1x001110xx1xxxxx100011xxxxxxxxxx
19473                                                              rax1.  */
19474                                                           return 2345;
19475                                                         }
19476                                                     }
19477                                                   else
19478                                                     {
19479                                                       /* 33222222222211111111110000000000
19480                                                          10987654321098765432109876543210
19481                                                          xx101110xx1xxxxx100011xxxxxxxxxx
19482                                                          cmeq.  */
19483                                                       return 336;
19484                                                     }
19485                                                 }
19486                                               else
19487                                                 {
19488                                                   if (((word >> 23) & 0x1) == 0)
19489                                                     {
19490                                                       if (((word >> 29) & 0x1) == 0)
19491                                                         {
19492                                                           /* 33222222222211111111110000000000
19493                                                              10987654321098765432109876543210
19494                                                              xx0011100x1xxxxx110011xxxxxxxxxx
19495                                                              fmla.  */
19496                                                           return 293;
19497                                                         }
19498                                                       else
19499                                                         {
19500                                                           if (((word >> 30) & 0x1) == 0)
19501                                                             {
19502                                                               /* 33222222222211111111110000000000
19503                                                                  10987654321098765432109876543210
19504                                                                  x01011100x1xxxxx110011xxxxxxxxxx
19505                                                                  fmlal2.  */
19506                                                               return 2359;
19507                                                             }
19508                                                           else
19509                                                             {
19510                                                               /* 33222222222211111111110000000000
19511                                                                  10987654321098765432109876543210
19512                                                                  x11011100x1xxxxx110011xxxxxxxxxx
19513                                                                  fmlal2.  */
19514                                                               return 2363;
19515                                                             }
19516                                                         }
19517                                                     }
19518                                                   else
19519                                                     {
19520                                                       if (((word >> 29) & 0x1) == 0)
19521                                                         {
19522                                                           /* 33222222222211111111110000000000
19523                                                              10987654321098765432109876543210
19524                                                              xx0011101x1xxxxx110011xxxxxxxxxx
19525                                                              fmls.  */
19526                                                           return 309;
19527                                                         }
19528                                                       else
19529                                                         {
19530                                                           if (((word >> 30) & 0x1) == 0)
19531                                                             {
19532                                                               /* 33222222222211111111110000000000
19533                                                                  10987654321098765432109876543210
19534                                                                  x01011101x1xxxxx110011xxxxxxxxxx
19535                                                                  fmlsl2.  */
19536                                                               return 2360;
19537                                                             }
19538                                                           else
19539                                                             {
19540                                                               /* 33222222222211111111110000000000
19541                                                                  10987654321098765432109876543210
19542                                                                  x11011101x1xxxxx110011xxxxxxxxxx
19543                                                                  fmlsl2.  */
19544                                                               return 2364;
19545                                                             }
19546                                                         }
19547                                                     }
19548                                                 }
19549                                             }
19550                                           else
19551                                             {
19552                                               if (((word >> 14) & 0x1) == 0)
19553                                                 {
19554                                                   if (((word >> 29) & 0x1) == 0)
19555                                                     {
19556                                                       /* 33222222222211111111110000000000
19557                                                          10987654321098765432109876543210
19558                                                          xx001110xx1xxxxx101011xxxxxxxxxx
19559                                                          sminp.  */
19560                                                       return 288;
19561                                                     }
19562                                                   else
19563                                                     {
19564                                                       /* 33222222222211111111110000000000
19565                                                          10987654321098765432109876543210
19566                                                          xx101110xx1xxxxx101011xxxxxxxxxx
19567                                                          uminp.  */
19568                                                       return 340;
19569                                                     }
19570                                                 }
19571                                               else
19572                                                 {
19573                                                   if (((word >> 23) & 0x1) == 0)
19574                                                     {
19575                                                       if (((word >> 29) & 0x1) == 0)
19576                                                         {
19577                                                           if (((word >> 30) & 0x1) == 0)
19578                                                             {
19579                                                               /* 33222222222211111111110000000000
19580                                                                  10987654321098765432109876543210
19581                                                                  x00011100x1xxxxx111011xxxxxxxxxx
19582                                                                  fmlal.  */
19583                                                               return 2357;
19584                                                             }
19585                                                           else
19586                                                             {
19587                                                               /* 33222222222211111111110000000000
19588                                                                  10987654321098765432109876543210
19589                                                                  x10011100x1xxxxx111011xxxxxxxxxx
19590                                                                  fmlal.  */
19591                                                               return 2361;
19592                                                             }
19593                                                         }
19594                                                       else
19595                                                         {
19596                                                           /* 33222222222211111111110000000000
19597                                                              10987654321098765432109876543210
19598                                                              xx1011100x1xxxxx111011xxxxxxxxxx
19599                                                              facge.  */
19600                                                           return 350;
19601                                                         }
19602                                                     }
19603                                                   else
19604                                                     {
19605                                                       if (((word >> 29) & 0x1) == 0)
19606                                                         {
19607                                                           if (((word >> 30) & 0x1) == 0)
19608                                                             {
19609                                                               /* 33222222222211111111110000000000
19610                                                                  10987654321098765432109876543210
19611                                                                  x00011101x1xxxxx111011xxxxxxxxxx
19612                                                                  fmlsl.  */
19613                                                               return 2358;
19614                                                             }
19615                                                           else
19616                                                             {
19617                                                               /* 33222222222211111111110000000000
19618                                                                  10987654321098765432109876543210
19619                                                                  x10011101x1xxxxx111011xxxxxxxxxx
19620                                                                  fmlsl.  */
19621                                                               return 2362;
19622                                                             }
19623                                                         }
19624                                                       else
19625                                                         {
19626                                                           /* 33222222222211111111110000000000
19627                                                              10987654321098765432109876543210
19628                                                              xx1011101x1xxxxx111011xxxxxxxxxx
19629                                                              facgt.  */
19630                                                           return 364;
19631                                                         }
19632                                                     }
19633                                                 }
19634                                             }
19635                                         }
19636                                       else
19637                                         {
19638                                           if (((word >> 13) & 0x1) == 0)
19639                                             {
19640                                               if (((word >> 14) & 0x1) == 0)
19641                                                 {
19642                                                   if (((word >> 29) & 0x1) == 0)
19643                                                     {
19644                                                       /* 33222222222211111111110000000000
19645                                                          10987654321098765432109876543210
19646                                                          xx001110xx1xxxxx100111xxxxxxxxxx
19647                                                          mul.  */
19648                                                       return 286;
19649                                                     }
19650                                                   else
19651                                                     {
19652                                                       /* 33222222222211111111110000000000
19653                                                          10987654321098765432109876543210
19654                                                          xx101110xx1xxxxx100111xxxxxxxxxx
19655                                                          pmul.  */
19656                                                       return 338;
19657                                                     }
19658                                                 }
19659                                               else
19660                                                 {
19661                                                   if (((word >> 29) & 0x1) == 0)
19662                                                     {
19663                                                       /* 33222222222211111111110000000000
19664                                                          10987654321098765432109876543210
19665                                                          xx001110xx1xxxxx110111xxxxxxxxxx
19666                                                          fmulx.  */
19667                                                       return 297;
19668                                                     }
19669                                                   else
19670                                                     {
19671                                                       /* 33222222222211111111110000000000
19672                                                          10987654321098765432109876543210
19673                                                          xx101110xx1xxxxx110111xxxxxxxxxx
19674                                                          fmul.  */
19675                                                       return 346;
19676                                                     }
19677                                                 }
19678                                             }
19679                                           else
19680                                             {
19681                                               if (((word >> 14) & 0x1) == 0)
19682                                                 {
19683                                                   /* 33222222222211111111110000000000
19684                                                      10987654321098765432109876543210
19685                                                      xxx01110xx1xxxxx101111xxxxxxxxxx
19686                                                      addp.  */
19687                                                   return 290;
19688                                                 }
19689                                               else
19690                                                 {
19691                                                   if (((word >> 23) & 0x1) == 0)
19692                                                     {
19693                                                       if (((word >> 29) & 0x1) == 0)
19694                                                         {
19695                                                           /* 33222222222211111111110000000000
19696                                                              10987654321098765432109876543210
19697                                                              xx0011100x1xxxxx111111xxxxxxxxxx
19698                                                              frecps.  */
19699                                                           return 303;
19700                                                         }
19701                                                       else
19702                                                         {
19703                                                           /* 33222222222211111111110000000000
19704                                                              10987654321098765432109876543210
19705                                                              xx1011100x1xxxxx111111xxxxxxxxxx
19706                                                              fdiv.  */
19707                                                           return 354;
19708                                                         }
19709                                                     }
19710                                                   else
19711                                                     {
19712                                                       /* 33222222222211111111110000000000
19713                                                          10987654321098765432109876543210
19714                                                          xxx011101x1xxxxx111111xxxxxxxxxx
19715                                                          frsqrts.  */
19716                                                       return 315;
19717                                                     }
19718                                                 }
19719                                             }
19720                                         }
19721                                     }
19722                                 }
19723                             }
19724                         }
19725                       else
19726                         {
19727                           if (((word >> 10) & 0x1) == 0)
19728                             {
19729                               if (((word >> 11) & 0x1) == 0)
19730                                 {
19731                                   if (((word >> 12) & 0x1) == 0)
19732                                     {
19733                                       if (((word >> 13) & 0x1) == 0)
19734                                         {
19735                                           if (((word >> 14) & 0x1) == 0)
19736                                             {
19737                                               if (((word >> 16) & 0x1) == 0)
19738                                                 {
19739                                                   if (((word >> 17) & 0x1) == 0)
19740                                                     {
19741                                                       if (((word >> 18) & 0x1) == 0)
19742                                                         {
19743                                                           if (((word >> 19) & 0x1) == 0)
19744                                                             {
19745                                                               if (((word >> 20) & 0x1) == 0)
19746                                                                 {
19747                                                                   /* 33222222222211111111110000000000
19748                                                                      10987654321098765432109876543210
19749                                                                      xxx11110xx100000x00000xxxxxxxxxx
19750                                                                      fcvtns.  */
19751                                                                   return 767;
19752                                                                 }
19753                                                               else
19754                                                                 {
19755                                                                   /* 33222222222211111111110000000000
19756                                                                      10987654321098765432109876543210
19757                                                                      xxx11110xx110000x00000xxxxxxxxxx
19758                                                                      fcvtms.  */
19759                                                                   return 787;
19760                                                                 }
19761                                                             }
19762                                                           else
19763                                                             {
19764                                                               if (((word >> 20) & 0x1) == 0)
19765                                                                 {
19766                                                                   /* 33222222222211111111110000000000
19767                                                                      10987654321098765432109876543210
19768                                                                      xxx11110xx101000x00000xxxxxxxxxx
19769                                                                      fcvtps.  */
19770                                                                   return 783;
19771                                                                 }
19772                                                               else
19773                                                                 {
19774                                                                   /* 33222222222211111111110000000000
19775                                                                      10987654321098765432109876543210
19776                                                                      xxx11110xx111000x00000xxxxxxxxxx
19777                                                                      fcvtzs.  */
19778                                                                   return 791;
19779                                                                 }
19780                                                             }
19781                                                         }
19782                                                       else
19783                                                         {
19784                                                           /* 33222222222211111111110000000000
19785                                                              10987654321098765432109876543210
19786                                                              xxx11110xx1xx100x00000xxxxxxxxxx
19787                                                              fcvtas.  */
19788                                                           return 775;
19789                                                         }
19790                                                     }
19791                                                   else
19792                                                     {
19793                                                       if (((word >> 18) & 0x1) == 0)
19794                                                         {
19795                                                           /* 33222222222211111111110000000000
19796                                                              10987654321098765432109876543210
19797                                                              xxx11110xx1xx010x00000xxxxxxxxxx
19798                                                              scvtf.  */
19799                                                           return 771;
19800                                                         }
19801                                                       else
19802                                                         {
19803                                                           if (((word >> 19) & 0x1) == 0)
19804                                                             {
19805                                                               /* 33222222222211111111110000000000
19806                                                                  10987654321098765432109876543210
19807                                                                  xxx11110xx1x0110x00000xxxxxxxxxx
19808                                                                  fmov.  */
19809                                                               return 779;
19810                                                             }
19811                                                           else
19812                                                             {
19813                                                               if (((word >> 20) & 0x1) == 0)
19814                                                                 {
19815                                                                   /* 33222222222211111111110000000000
19816                                                                      10987654321098765432109876543210
19817                                                                      xxx11110xx101110x00000xxxxxxxxxx
19818                                                                      fmov.  */
19819                                                                   return 795;
19820                                                                 }
19821                                                               else
19822                                                                 {
19823                                                                   /* 33222222222211111111110000000000
19824                                                                      10987654321098765432109876543210
19825                                                                      xxx11110xx111110x00000xxxxxxxxxx
19826                                                                      fjcvtzs.  */
19827                                                                   return 797;
19828                                                                 }
19829                                                             }
19830                                                         }
19831                                                     }
19832                                                 }
19833                                               else
19834                                                 {
19835                                                   if (((word >> 17) & 0x1) == 0)
19836                                                     {
19837                                                       if (((word >> 18) & 0x1) == 0)
19838                                                         {
19839                                                           if (((word >> 19) & 0x1) == 0)
19840                                                             {
19841                                                               if (((word >> 20) & 0x1) == 0)
19842                                                                 {
19843                                                                   /* 33222222222211111111110000000000
19844                                                                      10987654321098765432109876543210
19845                                                                      xxx11110xx100001x00000xxxxxxxxxx
19846                                                                      fcvtnu.  */
19847                                                                   return 769;
19848                                                                 }
19849                                                               else
19850                                                                 {
19851                                                                   /* 33222222222211111111110000000000
19852                                                                      10987654321098765432109876543210
19853                                                                      xxx11110xx110001x00000xxxxxxxxxx
19854                                                                      fcvtmu.  */
19855                                                                   return 789;
19856                                                                 }
19857                                                             }
19858                                                           else
19859                                                             {
19860                                                               if (((word >> 20) & 0x1) == 0)
19861                                                                 {
19862                                                                   /* 33222222222211111111110000000000
19863                                                                      10987654321098765432109876543210
19864                                                                      xxx11110xx101001x00000xxxxxxxxxx
19865                                                                      fcvtpu.  */
19866                                                                   return 785;
19867                                                                 }
19868                                                               else
19869                                                                 {
19870                                                                   /* 33222222222211111111110000000000
19871                                                                      10987654321098765432109876543210
19872                                                                      xxx11110xx111001x00000xxxxxxxxxx
19873                                                                      fcvtzu.  */
19874                                                                   return 793;
19875                                                                 }
19876                                                             }
19877                                                         }
19878                                                       else
19879                                                         {
19880                                                           /* 33222222222211111111110000000000
19881                                                              10987654321098765432109876543210
19882                                                              xxx11110xx1xx101x00000xxxxxxxxxx
19883                                                              fcvtau.  */
19884                                                           return 777;
19885                                                         }
19886                                                     }
19887                                                   else
19888                                                     {
19889                                                       if (((word >> 18) & 0x1) == 0)
19890                                                         {
19891                                                           /* 33222222222211111111110000000000
19892                                                              10987654321098765432109876543210
19893                                                              xxx11110xx1xx011x00000xxxxxxxxxx
19894                                                              ucvtf.  */
19895                                                           return 773;
19896                                                         }
19897                                                       else
19898                                                         {
19899                                                           if (((word >> 19) & 0x1) == 0)
19900                                                             {
19901                                                               /* 33222222222211111111110000000000
19902                                                                  10987654321098765432109876543210
19903                                                                  xxx11110xx1x0111x00000xxxxxxxxxx
19904                                                                  fmov.  */
19905                                                               return 781;
19906                                                             }
19907                                                           else
19908                                                             {
19909                                                               /* 33222222222211111111110000000000
19910                                                                  10987654321098765432109876543210
19911                                                                  xxx11110xx1x1111x00000xxxxxxxxxx
19912                                                                  fmov.  */
19913                                                               return 796;
19914                                                             }
19915                                                         }
19916                                                     }
19917                                                 }
19918                                             }
19919                                           else
19920                                             {
19921                                               if (((word >> 17) & 0x1) == 0)
19922                                                 {
19923                                                   if (((word >> 15) & 0x1) == 0)
19924                                                     {
19925                                                       if (((word >> 16) & 0x1) == 0)
19926                                                         {
19927                                                           if (((word >> 18) & 0x1) == 0)
19928                                                             {
19929                                                               if (((word >> 19) & 0x1) == 0)
19930                                                                 {
19931                                                                   /* 33222222222211111111110000000000
19932                                                                      10987654321098765432109876543210
19933                                                                      xxx11110xx1x0000010000xxxxxxxxxx
19934                                                                      fmov.  */
19935                                                                   return 816;
19936                                                                 }
19937                                                               else
19938                                                                 {
19939                                                                   /* 33222222222211111111110000000000
19940                                                                      10987654321098765432109876543210
19941                                                                      xxx11110xx1x1000010000xxxxxxxxxx
19942                                                                      frint32z.  */
19943                                                                   return 812;
19944                                                                 }
19945                                                             }
19946                                                           else
19947                                                             {
19948                                                               /* 33222222222211111111110000000000
19949                                                                  10987654321098765432109876543210
19950                                                                  xxx11110xx1xx100010000xxxxxxxxxx
19951                                                                  frintn.  */
19952                                                               return 825;
19953                                                             }
19954                                                         }
19955                                                       else
19956                                                         {
19957                                                           if (((word >> 18) & 0x1) == 0)
19958                                                             {
19959                                                               if (((word >> 19) & 0x1) == 0)
19960                                                                 {
19961                                                                   /* 33222222222211111111110000000000
19962                                                                      10987654321098765432109876543210
19963                                                                      xxx11110xx1x0001010000xxxxxxxxxx
19964                                                                      fneg.  */
19965                                                                   return 820;
19966                                                                 }
19967                                                               else
19968                                                                 {
19969                                                                   /* 33222222222211111111110000000000
19970                                                                      10987654321098765432109876543210
19971                                                                      xxx11110xx1x1001010000xxxxxxxxxx
19972                                                                      frint64z.  */
19973                                                                   return 814;
19974                                                                 }
19975                                                             }
19976                                                           else
19977                                                             {
19978                                                               /* 33222222222211111111110000000000
19979                                                                  10987654321098765432109876543210
19980                                                                  xxx11110xx1xx101010000xxxxxxxxxx
19981                                                                  frintm.  */
19982                                                               return 829;
19983                                                             }
19984                                                         }
19985                                                     }
19986                                                   else
19987                                                     {
19988                                                       if (((word >> 16) & 0x1) == 0)
19989                                                         {
19990                                                           if (((word >> 18) & 0x1) == 0)
19991                                                             {
19992                                                               if (((word >> 19) & 0x1) == 0)
19993                                                                 {
19994                                                                   /* 33222222222211111111110000000000
19995                                                                      10987654321098765432109876543210
19996                                                                      xxx11110xx1x0000110000xxxxxxxxxx
19997                                                                      fabs.  */
19998                                                                   return 818;
19999                                                                 }
20000                                                               else
20001                                                                 {
20002                                                                   /* 33222222222211111111110000000000
20003                                                                      10987654321098765432109876543210
20004                                                                      xxx11110xx1x1000110000xxxxxxxxxx
20005                                                                      frint32x.  */
20006                                                                   return 813;
20007                                                                 }
20008                                                             }
20009                                                           else
20010                                                             {
20011                                                               /* 33222222222211111111110000000000
20012                                                                  10987654321098765432109876543210
20013                                                                  xxx11110xx1xx100110000xxxxxxxxxx
20014                                                                  frintp.  */
20015                                                               return 827;
20016                                                             }
20017                                                         }
20018                                                       else
20019                                                         {
20020                                                           if (((word >> 18) & 0x1) == 0)
20021                                                             {
20022                                                               if (((word >> 19) & 0x1) == 0)
20023                                                                 {
20024                                                                   /* 33222222222211111111110000000000
20025                                                                      10987654321098765432109876543210
20026                                                                      xxx11110xx1x0001110000xxxxxxxxxx
20027                                                                      fsqrt.  */
20028                                                                   return 822;
20029                                                                 }
20030                                                               else
20031                                                                 {
20032                                                                   /* 33222222222211111111110000000000
20033                                                                      10987654321098765432109876543210
20034                                                                      xxx11110xx1x1001110000xxxxxxxxxx
20035                                                                      frint64x.  */
20036                                                                   return 815;
20037                                                                 }
20038                                                             }
20039                                                           else
20040                                                             {
20041                                                               /* 33222222222211111111110000000000
20042                                                                  10987654321098765432109876543210
20043                                                                  xxx11110xx1xx101110000xxxxxxxxxx
20044                                                                  frintz.  */
20045                                                               return 831;
20046                                                             }
20047                                                         }
20048                                                     }
20049                                                 }
20050                                               else
20051                                                 {
20052                                                   if (((word >> 18) & 0x1) == 0)
20053                                                     {
20054                                                       /* 33222222222211111111110000000000
20055                                                          10987654321098765432109876543210
20056                                                          xxx11110xx1xx01xx10000xxxxxxxxxx
20057                                                          fcvt.  */
20058                                                       return 824;
20059                                                     }
20060                                                   else
20061                                                     {
20062                                                       if (((word >> 15) & 0x1) == 0)
20063                                                         {
20064                                                           if (((word >> 16) & 0x1) == 0)
20065                                                             {
20066                                                               /* 33222222222211111111110000000000
20067                                                                  10987654321098765432109876543210
20068                                                                  xxx11110xx1xx110010000xxxxxxxxxx
20069                                                                  frinta.  */
20070                                                               return 833;
20071                                                             }
20072                                                           else
20073                                                             {
20074                                                               /* 33222222222211111111110000000000
20075                                                                  10987654321098765432109876543210
20076                                                                  xxx11110xx1xx111010000xxxxxxxxxx
20077                                                                  frintx.  */
20078                                                               return 835;
20079                                                             }
20080                                                         }
20081                                                       else
20082                                                         {
20083                                                           /* 33222222222211111111110000000000
20084                                                              10987654321098765432109876543210
20085                                                              xxx11110xx1xx11x110000xxxxxxxxxx
20086                                                              frinti.  */
20087                                                           return 837;
20088                                                         }
20089                                                     }
20090                                                 }
20091                                             }
20092                                         }
20093                                       else
20094                                         {
20095                                           if (((word >> 3) & 0x1) == 0)
20096                                             {
20097                                               if (((word >> 4) & 0x1) == 0)
20098                                                 {
20099                                                   /* 33222222222211111111110000000000
20100                                                      10987654321098765432109876543210
20101                                                      xxx11110xx1xxxxxxx1000xxxxx00xxx
20102                                                      fcmp.  */
20103                                                   return 802;
20104                                                 }
20105                                               else
20106                                                 {
20107                                                   /* 33222222222211111111110000000000
20108                                                      10987654321098765432109876543210
20109                                                      xxx11110xx1xxxxxxx1000xxxxx10xxx
20110                                                      fcmpe.  */
20111                                                   return 804;
20112                                                 }
20113                                             }
20114                                           else
20115                                             {
20116                                               if (((word >> 4) & 0x1) == 0)
20117                                                 {
20118                                                   /* 33222222222211111111110000000000
20119                                                      10987654321098765432109876543210
20120                                                      xxx11110xx1xxxxxxx1000xxxxx01xxx
20121                                                      fcmp.  */
20122                                                   return 806;
20123                                                 }
20124                                               else
20125                                                 {
20126                                                   /* 33222222222211111111110000000000
20127                                                      10987654321098765432109876543210
20128                                                      xxx11110xx1xxxxxxx1000xxxxx11xxx
20129                                                      fcmpe.  */
20130                                                   return 808;
20131                                                 }
20132                                             }
20133                                         }
20134                                     }
20135                                   else
20136                                     {
20137                                       if (((word >> 30) & 0x1) == 0)
20138                                         {
20139                                           /* 33222222222211111111110000000000
20140                                              10987654321098765432109876543210
20141                                              x0x11110xx1xxxxxxxx100xxxxxxxxxx
20142                                              fmov.  */
20143                                           return 865;
20144                                         }
20145                                       else
20146                                         {
20147                                           if (((word >> 13) & 0x1) == 0)
20148                                             {
20149                                               if (((word >> 14) & 0x1) == 0)
20150                                                 {
20151                                                   /* 33222222222211111111110000000000
20152                                                      10987654321098765432109876543210
20153                                                      x1x11110xx1xxxxxx00100xxxxxxxxxx
20154                                                      sqdmlal.  */
20155                                                   return 422;
20156                                                 }
20157                                               else
20158                                                 {
20159                                                   /* 33222222222211111111110000000000
20160                                                      10987654321098765432109876543210
20161                                                      x1x11110xx1xxxxxx10100xxxxxxxxxx
20162                                                      sqdmull.  */
20163                                                   return 424;
20164                                                 }
20165                                             }
20166                                           else
20167                                             {
20168                                               /* 33222222222211111111110000000000
20169                                                  10987654321098765432109876543210
20170                                                  x1x11110xx1xxxxxxx1100xxxxxxxxxx
20171                                                  sqdmlsl.  */
20172                                               return 423;
20173                                             }
20174                                         }
20175                                     }
20176                                 }
20177                               else
20178                                 {
20179                                   if (((word >> 12) & 0x1) == 0)
20180                                     {
20181                                       if (((word >> 13) & 0x1) == 0)
20182                                         {
20183                                           if (((word >> 14) & 0x1) == 0)
20184                                             {
20185                                               if (((word >> 15) & 0x1) == 0)
20186                                                 {
20187                                                   if (((word >> 30) & 0x1) == 0)
20188                                                     {
20189                                                       /* 33222222222211111111110000000000
20190                                                          10987654321098765432109876543210
20191                                                          x0x11110xx1xxxxx000010xxxxxxxxxx
20192                                                          fmul.  */
20193                                                       return 839;
20194                                                     }
20195                                                   else
20196                                                     {
20197                                                       /* 33222222222211111111110000000000
20198                                                          10987654321098765432109876543210
20199                                                          x1x11110xx1xxxxx000010xxxxxxxxxx
20200                                                          sha1h.  */
20201                                                       return 675;
20202                                                     }
20203                                                 }
20204                                               else
20205                                                 {
20206                                                   if (((word >> 29) & 0x1) == 0)
20207                                                     {
20208                                                       if (((word >> 30) & 0x1) == 0)
20209                                                         {
20210                                                           /* 33222222222211111111110000000000
20211                                                              10987654321098765432109876543210
20212                                                              x0011110xx1xxxxx100010xxxxxxxxxx
20213                                                              fnmul.  */
20214                                                           return 855;
20215                                                         }
20216                                                       else
20217                                                         {
20218                                                           /* 33222222222211111111110000000000
20219                                                              10987654321098765432109876543210
20220                                                              x1011110xx1xxxxx100010xxxxxxxxxx
20221                                                              cmgt.  */
20222                                                           return 482;
20223                                                         }
20224                                                     }
20225                                                   else
20226                                                     {
20227                                                       /* 33222222222211111111110000000000
20228                                                          10987654321098765432109876543210
20229                                                          xx111110xx1xxxxx100010xxxxxxxxxx
20230                                                          cmge.  */
20231                                                       return 511;
20232                                                     }
20233                                                 }
20234                                             }
20235                                           else
20236                                             {
20237                                               if (((word >> 15) & 0x1) == 0)
20238                                                 {
20239                                                   if (((word >> 29) & 0x1) == 0)
20240                                                     {
20241                                                       if (((word >> 30) & 0x1) == 0)
20242                                                         {
20243                                                           /* 33222222222211111111110000000000
20244                                                              10987654321098765432109876543210
20245                                                              x0011110xx1xxxxx010010xxxxxxxxxx
20246                                                              fmax.  */
20247                                                           return 847;
20248                                                         }
20249                                                       else
20250                                                         {
20251                                                           /* 33222222222211111111110000000000
20252                                                              10987654321098765432109876543210
20253                                                              x1011110xx1xxxxx010010xxxxxxxxxx
20254                                                              sqxtn.  */
20255                                                           return 486;
20256                                                         }
20257                                                     }
20258                                                   else
20259                                                     {
20260                                                       /* 33222222222211111111110000000000
20261                                                          10987654321098765432109876543210
20262                                                          xx111110xx1xxxxx010010xxxxxxxxxx
20263                                                          uqxtn.  */
20264                                                       return 515;
20265                                                     }
20266                                                 }
20267                                               else
20268                                                 {
20269                                                   if (((word >> 16) & 0x1) == 0)
20270                                                     {
20271                                                       if (((word >> 19) & 0x1) == 0)
20272                                                         {
20273                                                           if (((word >> 20) & 0x1) == 0)
20274                                                             {
20275                                                               if (((word >> 29) & 0x1) == 0)
20276                                                                 {
20277                                                                   /* 33222222222211111111110000000000
20278                                                                      10987654321098765432109876543210
20279                                                                      xx011110xx100xx0110010xxxxxxxxxx
20280                                                                      fcmgt.  */
20281                                                                   return 495;
20282                                                                 }
20283                                                               else
20284                                                                 {
20285                                                                   /* 33222222222211111111110000000000
20286                                                                      10987654321098765432109876543210
20287                                                                      xx111110xx100xx0110010xxxxxxxxxx
20288                                                                      fcmge.  */
20289                                                                   return 525;
20290                                                                 }
20291                                                             }
20292                                                           else
20293                                                             {
20294                                                               if (((word >> 23) & 0x1) == 0)
20295                                                                 {
20296                                                                   if (((word >> 29) & 0x1) == 0)
20297                                                                     {
20298                                                                       /* 33222222222211111111110000000000
20299                                                                          10987654321098765432109876543210
20300                                                                          xx0111100x110xx0110010xxxxxxxxxx
20301                                                                          fmaxnmp.  */
20302                                                                       return 539;
20303                                                                     }
20304                                                                   else
20305                                                                     {
20306                                                                       /* 33222222222211111111110000000000
20307                                                                          10987654321098765432109876543210
20308                                                                          xx1111100x110xx0110010xxxxxxxxxx
20309                                                                          fmaxnmp.  */
20310                                                                       return 538;
20311                                                                     }
20312                                                                 }
20313                                                               else
20314                                                                 {
20315                                                                   if (((word >> 29) & 0x1) == 0)
20316                                                                     {
20317                                                                       /* 33222222222211111111110000000000
20318                                                                          10987654321098765432109876543210
20319                                                                          xx0111101x110xx0110010xxxxxxxxxx
20320                                                                          fminnmp.  */
20321                                                                       return 545;
20322                                                                     }
20323                                                                   else
20324                                                                     {
20325                                                                       /* 33222222222211111111110000000000
20326                                                                          10987654321098765432109876543210
20327                                                                          xx1111101x110xx0110010xxxxxxxxxx
20328                                                                          fminnmp.  */
20329                                                                       return 544;
20330                                                                     }
20331                                                                 }
20332                                                             }
20333                                                         }
20334                                                       else
20335                                                         {
20336                                                           if (((word >> 29) & 0x1) == 0)
20337                                                             {
20338                                                               /* 33222222222211111111110000000000
20339                                                                  10987654321098765432109876543210
20340                                                                  xx011110xx1x1xx0110010xxxxxxxxxx
20341                                                                  fcmgt.  */
20342                                                               return 496;
20343                                                             }
20344                                                           else
20345                                                             {
20346                                                               /* 33222222222211111111110000000000
20347                                                                  10987654321098765432109876543210
20348                                                                  xx111110xx1x1xx0110010xxxxxxxxxx
20349                                                                  fcmge.  */
20350                                                               return 526;
20351                                                             }
20352                                                         }
20353                                                     }
20354                                                   else
20355                                                     {
20356                                                       if (((word >> 19) & 0x1) == 0)
20357                                                         {
20358                                                           if (((word >> 29) & 0x1) == 0)
20359                                                             {
20360                                                               /* 33222222222211111111110000000000
20361                                                                  10987654321098765432109876543210
20362                                                                  xx011110xx1x0xx1110010xxxxxxxxxx
20363                                                                  fcvtas.  */
20364                                                               return 491;
20365                                                             }
20366                                                           else
20367                                                             {
20368                                                               /* 33222222222211111111110000000000
20369                                                                  10987654321098765432109876543210
20370                                                                  xx111110xx1x0xx1110010xxxxxxxxxx
20371                                                                  fcvtau.  */
20372                                                               return 521;
20373                                                             }
20374                                                         }
20375                                                       else
20376                                                         {
20377                                                           if (((word >> 29) & 0x1) == 0)
20378                                                             {
20379                                                               /* 33222222222211111111110000000000
20380                                                                  10987654321098765432109876543210
20381                                                                  xx011110xx1x1xx1110010xxxxxxxxxx
20382                                                                  fcvtas.  */
20383                                                               return 492;
20384                                                             }
20385                                                           else
20386                                                             {
20387                                                               /* 33222222222211111111110000000000
20388                                                                  10987654321098765432109876543210
20389                                                                  xx111110xx1x1xx1110010xxxxxxxxxx
20390                                                                  fcvtau.  */
20391                                                               return 522;
20392                                                             }
20393                                                         }
20394                                                     }
20395                                                 }
20396                                             }
20397                                         }
20398                                       else
20399                                         {
20400                                           if (((word >> 14) & 0x1) == 0)
20401                                             {
20402                                               if (((word >> 15) & 0x1) == 0)
20403                                                 {
20404                                                   if (((word >> 29) & 0x1) == 0)
20405                                                     {
20406                                                       if (((word >> 30) & 0x1) == 0)
20407                                                         {
20408                                                           /* 33222222222211111111110000000000
20409                                                              10987654321098765432109876543210
20410                                                              x0011110xx1xxxxx001010xxxxxxxxxx
20411                                                              fadd.  */
20412                                                           return 843;
20413                                                         }
20414                                                       else
20415                                                         {
20416                                                           /* 33222222222211111111110000000000
20417                                                              10987654321098765432109876543210
20418                                                              x1011110xx1xxxxx001010xxxxxxxxxx
20419                                                              sha256su0.  */
20420                                                           return 677;
20421                                                         }
20422                                                     }
20423                                                   else
20424                                                     {
20425                                                       /* 33222222222211111111110000000000
20426                                                          10987654321098765432109876543210
20427                                                          xx111110xx1xxxxx001010xxxxxxxxxx
20428                                                          sqxtun.  */
20429                                                       return 514;
20430                                                     }
20431                                                 }
20432                                               else
20433                                                 {
20434                                                   if (((word >> 16) & 0x1) == 0)
20435                                                     {
20436                                                       /* 33222222222211111111110000000000
20437                                                          10987654321098765432109876543210
20438                                                          xxx11110xx1xxxx0101010xxxxxxxxxx
20439                                                          cmlt.  */
20440                                                       return 484;
20441                                                     }
20442                                                   else
20443                                                     {
20444                                                       if (((word >> 19) & 0x1) == 0)
20445                                                         {
20446                                                           if (((word >> 23) & 0x1) == 0)
20447                                                             {
20448                                                               if (((word >> 29) & 0x1) == 0)
20449                                                                 {
20450                                                                   /* 33222222222211111111110000000000
20451                                                                      10987654321098765432109876543210
20452                                                                      xx0111100x1x0xx1101010xxxxxxxxxx
20453                                                                      fcvtns.  */
20454                                                                   return 487;
20455                                                                 }
20456                                                               else
20457                                                                 {
20458                                                                   /* 33222222222211111111110000000000
20459                                                                      10987654321098765432109876543210
20460                                                                      xx1111100x1x0xx1101010xxxxxxxxxx
20461                                                                      fcvtnu.  */
20462                                                                   return 517;
20463                                                                 }
20464                                                             }
20465                                                           else
20466                                                             {
20467                                                               if (((word >> 29) & 0x1) == 0)
20468                                                                 {
20469                                                                   /* 33222222222211111111110000000000
20470                                                                      10987654321098765432109876543210
20471                                                                      xx0111101x1x0xx1101010xxxxxxxxxx
20472                                                                      fcvtps.  */
20473                                                                   return 501;
20474                                                                 }
20475                                                               else
20476                                                                 {
20477                                                                   /* 33222222222211111111110000000000
20478                                                                      10987654321098765432109876543210
20479                                                                      xx1111101x1x0xx1101010xxxxxxxxxx
20480                                                                      fcvtpu.  */
20481                                                                   return 529;
20482                                                                 }
20483                                                             }
20484                                                         }
20485                                                       else
20486                                                         {
20487                                                           if (((word >> 23) & 0x1) == 0)
20488                                                             {
20489                                                               if (((word >> 29) & 0x1) == 0)
20490                                                                 {
20491                                                                   /* 33222222222211111111110000000000
20492                                                                      10987654321098765432109876543210
20493                                                                      xx0111100x1x1xx1101010xxxxxxxxxx
20494                                                                      fcvtns.  */
20495                                                                   return 488;
20496                                                                 }
20497                                                               else
20498                                                                 {
20499                                                                   /* 33222222222211111111110000000000
20500                                                                      10987654321098765432109876543210
20501                                                                      xx1111100x1x1xx1101010xxxxxxxxxx
20502                                                                      fcvtnu.  */
20503                                                                   return 518;
20504                                                                 }
20505                                                             }
20506                                                           else
20507                                                             {
20508                                                               if (((word >> 29) & 0x1) == 0)
20509                                                                 {
20510                                                                   /* 33222222222211111111110000000000
20511                                                                      10987654321098765432109876543210
20512                                                                      xx0111101x1x1xx1101010xxxxxxxxxx
20513                                                                      fcvtps.  */
20514                                                                   return 502;
20515                                                                 }
20516                                                               else
20517                                                                 {
20518                                                                   /* 33222222222211111111110000000000
20519                                                                      10987654321098765432109876543210
20520                                                                      xx1111101x1x1xx1101010xxxxxxxxxx
20521                                                                      fcvtpu.  */
20522                                                                   return 530;
20523                                                                 }
20524                                                             }
20525                                                         }
20526                                                     }
20527                                                 }
20528                                             }
20529                                           else
20530                                             {
20531                                               if (((word >> 15) & 0x1) == 0)
20532                                                 {
20533                                                   if (((word >> 29) & 0x1) == 0)
20534                                                     {
20535                                                       /* 33222222222211111111110000000000
20536                                                          10987654321098765432109876543210
20537                                                          xx011110xx1xxxxx011010xxxxxxxxxx
20538                                                          fmaxnm.  */
20539                                                       return 851;
20540                                                     }
20541                                                   else
20542                                                     {
20543                                                       /* 33222222222211111111110000000000
20544                                                          10987654321098765432109876543210
20545                                                          xx111110xx1xxxxx011010xxxxxxxxxx
20546                                                          fcvtxn.  */
20547                                                       return 516;
20548                                                     }
20549                                                 }
20550                                               else
20551                                                 {
20552                                                   if (((word >> 19) & 0x1) == 0)
20553                                                     {
20554                                                       /* 33222222222211111111110000000000
20555                                                          10987654321098765432109876543210
20556                                                          xxx11110xx1x0xxx111010xxxxxxxxxx
20557                                                          fcmlt.  */
20558                                                       return 499;
20559                                                     }
20560                                                   else
20561                                                     {
20562                                                       /* 33222222222211111111110000000000
20563                                                          10987654321098765432109876543210
20564                                                          xxx11110xx1x1xxx111010xxxxxxxxxx
20565                                                          fcmlt.  */
20566                                                       return 500;
20567                                                     }
20568                                                 }
20569                                             }
20570                                         }
20571                                     }
20572                                   else
20573                                     {
20574                                       if (((word >> 13) & 0x1) == 0)
20575                                         {
20576                                           if (((word >> 14) & 0x1) == 0)
20577                                             {
20578                                               if (((word >> 15) & 0x1) == 0)
20579                                                 {
20580                                                   if (((word >> 30) & 0x1) == 0)
20581                                                     {
20582                                                       /* 33222222222211111111110000000000
20583                                                          10987654321098765432109876543210
20584                                                          x0x11110xx1xxxxx000110xxxxxxxxxx
20585                                                          fdiv.  */
20586                                                       return 841;
20587                                                     }
20588                                                   else
20589                                                     {
20590                                                       /* 33222222222211111111110000000000
20591                                                          10987654321098765432109876543210
20592                                                          x1x11110xx1xxxxx000110xxxxxxxxxx
20593                                                          sha1su1.  */
20594                                                       return 676;
20595                                                     }
20596                                                 }
20597                                               else
20598                                                 {
20599                                                   if (((word >> 29) & 0x1) == 0)
20600                                                     {
20601                                                       /* 33222222222211111111110000000000
20602                                                          10987654321098765432109876543210
20603                                                          xx011110xx1xxxxx100110xxxxxxxxxx
20604                                                          cmeq.  */
20605                                                       return 483;
20606                                                     }
20607                                                   else
20608                                                     {
20609                                                       /* 33222222222211111111110000000000
20610                                                          10987654321098765432109876543210
20611                                                          xx111110xx1xxxxx100110xxxxxxxxxx
20612                                                          cmle.  */
20613                                                       return 512;
20614                                                     }
20615                                                 }
20616                                             }
20617                                           else
20618                                             {
20619                                               if (((word >> 15) & 0x1) == 0)
20620                                                 {
20621                                                   /* 33222222222211111111110000000000
20622                                                      10987654321098765432109876543210
20623                                                      xxx11110xx1xxxxx010110xxxxxxxxxx
20624                                                      fmin.  */
20625                                                   return 849;
20626                                                 }
20627                                               else
20628                                                 {
20629                                                   if (((word >> 16) & 0x1) == 0)
20630                                                     {
20631                                                       if (((word >> 19) & 0x1) == 0)
20632                                                         {
20633                                                           if (((word >> 20) & 0x1) == 0)
20634                                                             {
20635                                                               if (((word >> 29) & 0x1) == 0)
20636                                                                 {
20637                                                                   /* 33222222222211111111110000000000
20638                                                                      10987654321098765432109876543210
20639                                                                      xx011110xx100xx0110110xxxxxxxxxx
20640                                                                      fcmeq.  */
20641                                                                   return 497;
20642                                                                 }
20643                                                               else
20644                                                                 {
20645                                                                   /* 33222222222211111111110000000000
20646                                                                      10987654321098765432109876543210
20647                                                                      xx111110xx100xx0110110xxxxxxxxxx
20648                                                                      fcmle.  */
20649                                                                   return 527;
20650                                                                 }
20651                                                             }
20652                                                           else
20653                                                             {
20654                                                               if (((word >> 29) & 0x1) == 0)
20655                                                                 {
20656                                                                   /* 33222222222211111111110000000000
20657                                                                      10987654321098765432109876543210
20658                                                                      xx011110xx110xx0110110xxxxxxxxxx
20659                                                                      faddp.  */
20660                                                                   return 541;
20661                                                                 }
20662                                                               else
20663                                                                 {
20664                                                                   /* 33222222222211111111110000000000
20665                                                                      10987654321098765432109876543210
20666                                                                      xx111110xx110xx0110110xxxxxxxxxx
20667                                                                      faddp.  */
20668                                                                   return 540;
20669                                                                 }
20670                                                             }
20671                                                         }
20672                                                       else
20673                                                         {
20674                                                           if (((word >> 29) & 0x1) == 0)
20675                                                             {
20676                                                               /* 33222222222211111111110000000000
20677                                                                  10987654321098765432109876543210
20678                                                                  xx011110xx1x1xx0110110xxxxxxxxxx
20679                                                                  fcmeq.  */
20680                                                               return 498;
20681                                                             }
20682                                                           else
20683                                                             {
20684                                                               /* 33222222222211111111110000000000
20685                                                                  10987654321098765432109876543210
20686                                                                  xx111110xx1x1xx0110110xxxxxxxxxx
20687                                                                  fcmle.  */
20688                                                               return 528;
20689                                                             }
20690                                                         }
20691                                                     }
20692                                                   else
20693                                                     {
20694                                                       if (((word >> 19) & 0x1) == 0)
20695                                                         {
20696                                                           if (((word >> 23) & 0x1) == 0)
20697                                                             {
20698                                                               if (((word >> 29) & 0x1) == 0)
20699                                                                 {
20700                                                                   /* 33222222222211111111110000000000
20701                                                                      10987654321098765432109876543210
20702                                                                      xx0111100x1x0xx1110110xxxxxxxxxx
20703                                                                      scvtf.  */
20704                                                                   return 493;
20705                                                                 }
20706                                                               else
20707                                                                 {
20708                                                                   /* 33222222222211111111110000000000
20709                                                                      10987654321098765432109876543210
20710                                                                      xx1111100x1x0xx1110110xxxxxxxxxx
20711                                                                      ucvtf.  */
20712                                                                   return 523;
20713                                                                 }
20714                                                             }
20715                                                           else
20716                                                             {
20717                                                               if (((word >> 29) & 0x1) == 0)
20718                                                                 {
20719                                                                   /* 33222222222211111111110000000000
20720                                                                      10987654321098765432109876543210
20721                                                                      xx0111101x1x0xx1110110xxxxxxxxxx
20722                                                                      frecpe.  */
20723                                                                   return 505;
20724                                                                 }
20725                                                               else
20726                                                                 {
20727                                                                   /* 33222222222211111111110000000000
20728                                                                      10987654321098765432109876543210
20729                                                                      xx1111101x1x0xx1110110xxxxxxxxxx
20730                                                                      frsqrte.  */
20731                                                                   return 533;
20732                                                                 }
20733                                                             }
20734                                                         }
20735                                                       else
20736                                                         {
20737                                                           if (((word >> 23) & 0x1) == 0)
20738                                                             {
20739                                                               if (((word >> 29) & 0x1) == 0)
20740                                                                 {
20741                                                                   /* 33222222222211111111110000000000
20742                                                                      10987654321098765432109876543210
20743                                                                      xx0111100x1x1xx1110110xxxxxxxxxx
20744                                                                      scvtf.  */
20745                                                                   return 494;
20746                                                                 }
20747                                                               else
20748                                                                 {
20749                                                                   /* 33222222222211111111110000000000
20750                                                                      10987654321098765432109876543210
20751                                                                      xx1111100x1x1xx1110110xxxxxxxxxx
20752                                                                      ucvtf.  */
20753                                                                   return 524;
20754                                                                 }
20755                                                             }
20756                                                           else
20757                                                             {
20758                                                               if (((word >> 29) & 0x1) == 0)
20759                                                                 {
20760                                                                   /* 33222222222211111111110000000000
20761                                                                      10987654321098765432109876543210
20762                                                                      xx0111101x1x1xx1110110xxxxxxxxxx
20763                                                                      frecpe.  */
20764                                                                   return 506;
20765                                                                 }
20766                                                               else
20767                                                                 {
20768                                                                   /* 33222222222211111111110000000000
20769                                                                      10987654321098765432109876543210
20770                                                                      xx1111101x1x1xx1110110xxxxxxxxxx
20771                                                                      frsqrte.  */
20772                                                                   return 534;
20773                                                                 }
20774                                                             }
20775                                                         }
20776                                                     }
20777                                                 }
20778                                             }
20779                                         }
20780                                       else
20781                                         {
20782                                           if (((word >> 14) & 0x1) == 0)
20783                                             {
20784                                               if (((word >> 15) & 0x1) == 0)
20785                                                 {
20786                                                   if (((word >> 29) & 0x1) == 0)
20787                                                     {
20788                                                       if (((word >> 30) & 0x1) == 0)
20789                                                         {
20790                                                           /* 33222222222211111111110000000000
20791                                                              10987654321098765432109876543210
20792                                                              x0011110xx1xxxxx001110xxxxxxxxxx
20793                                                              fsub.  */
20794                                                           return 845;
20795                                                         }
20796                                                       else
20797                                                         {
20798                                                           /* 33222222222211111111110000000000
20799                                                              10987654321098765432109876543210
20800                                                              x1011110xx1xxxxx001110xxxxxxxxxx
20801                                                              suqadd.  */
20802                                                           return 480;
20803                                                         }
20804                                                     }
20805                                                   else
20806                                                     {
20807                                                       /* 33222222222211111111110000000000
20808                                                          10987654321098765432109876543210
20809                                                          xx111110xx1xxxxx001110xxxxxxxxxx
20810                                                          usqadd.  */
20811                                                       return 509;
20812                                                     }
20813                                                 }
20814                                               else
20815                                                 {
20816                                                   if (((word >> 16) & 0x1) == 0)
20817                                                     {
20818                                                       if (((word >> 29) & 0x1) == 0)
20819                                                         {
20820                                                           /* 33222222222211111111110000000000
20821                                                              10987654321098765432109876543210
20822                                                              xx011110xx1xxxx0101110xxxxxxxxxx
20823                                                              abs.  */
20824                                                           return 485;
20825                                                         }
20826                                                       else
20827                                                         {
20828                                                           /* 33222222222211111111110000000000
20829                                                              10987654321098765432109876543210
20830                                                              xx111110xx1xxxx0101110xxxxxxxxxx
20831                                                              neg.  */
20832                                                           return 513;
20833                                                         }
20834                                                     }
20835                                                   else
20836                                                     {
20837                                                       if (((word >> 19) & 0x1) == 0)
20838                                                         {
20839                                                           if (((word >> 20) & 0x1) == 0)
20840                                                             {
20841                                                               if (((word >> 23) & 0x1) == 0)
20842                                                                 {
20843                                                                   if (((word >> 29) & 0x1) == 0)
20844                                                                     {
20845                                                                       /* 33222222222211111111110000000000
20846                                                                          10987654321098765432109876543210
20847                                                                          xx0111100x100xx1101110xxxxxxxxxx
20848                                                                          fcvtms.  */
20849                                                                       return 489;
20850                                                                     }
20851                                                                   else
20852                                                                     {
20853                                                                       /* 33222222222211111111110000000000
20854                                                                          10987654321098765432109876543210
20855                                                                          xx1111100x100xx1101110xxxxxxxxxx
20856                                                                          fcvtmu.  */
20857                                                                       return 519;
20858                                                                     }
20859                                                                 }
20860                                                               else
20861                                                                 {
20862                                                                   if (((word >> 29) & 0x1) == 0)
20863                                                                     {
20864                                                                       /* 33222222222211111111110000000000
20865                                                                          10987654321098765432109876543210
20866                                                                          xx0111101x100xx1101110xxxxxxxxxx
20867                                                                          fcvtzs.  */
20868                                                                       return 503;
20869                                                                     }
20870                                                                   else
20871                                                                     {
20872                                                                       /* 33222222222211111111110000000000
20873                                                                          10987654321098765432109876543210
20874                                                                          xx1111101x100xx1101110xxxxxxxxxx
20875                                                                          fcvtzu.  */
20876                                                                       return 531;
20877                                                                     }
20878                                                                 }
20879                                                             }
20880                                                           else
20881                                                             {
20882                                                               /* 33222222222211111111110000000000
20883                                                                  10987654321098765432109876543210
20884                                                                  xxx11110xx110xx1101110xxxxxxxxxx
20885                                                                  addp.  */
20886                                                               return 537;
20887                                                             }
20888                                                         }
20889                                                       else
20890                                                         {
20891                                                           if (((word >> 23) & 0x1) == 0)
20892                                                             {
20893                                                               if (((word >> 29) & 0x1) == 0)
20894                                                                 {
20895                                                                   /* 33222222222211111111110000000000
20896                                                                      10987654321098765432109876543210
20897                                                                      xx0111100x1x1xx1101110xxxxxxxxxx
20898                                                                      fcvtms.  */
20899                                                                   return 490;
20900                                                                 }
20901                                                               else
20902                                                                 {
20903                                                                   /* 33222222222211111111110000000000
20904                                                                      10987654321098765432109876543210
20905                                                                      xx1111100x1x1xx1101110xxxxxxxxxx
20906                                                                      fcvtmu.  */
20907                                                                   return 520;
20908                                                                 }
20909                                                             }
20910                                                           else
20911                                                             {
20912                                                               if (((word >> 29) & 0x1) == 0)
20913                                                                 {
20914                                                                   /* 33222222222211111111110000000000
20915                                                                      10987654321098765432109876543210
20916                                                                      xx0111101x1x1xx1101110xxxxxxxxxx
20917                                                                      fcvtzs.  */
20918                                                                   return 504;
20919                                                                 }
20920                                                               else
20921                                                                 {
20922                                                                   /* 33222222222211111111110000000000
20923                                                                      10987654321098765432109876543210
20924                                                                      xx1111101x1x1xx1101110xxxxxxxxxx
20925                                                                      fcvtzu.  */
20926                                                                   return 532;
20927                                                                 }
20928                                                             }
20929                                                         }
20930                                                     }
20931                                                 }
20932                                             }
20933                                           else
20934                                             {
20935                                               if (((word >> 15) & 0x1) == 0)
20936                                                 {
20937                                                   if (((word >> 29) & 0x1) == 0)
20938                                                     {
20939                                                       if (((word >> 30) & 0x1) == 0)
20940                                                         {
20941                                                           /* 33222222222211111111110000000000
20942                                                              10987654321098765432109876543210
20943                                                              x0011110xx1xxxxx011110xxxxxxxxxx
20944                                                              fminnm.  */
20945                                                           return 853;
20946                                                         }
20947                                                       else
20948                                                         {
20949                                                           /* 33222222222211111111110000000000
20950                                                              10987654321098765432109876543210
20951                                                              x1011110xx1xxxxx011110xxxxxxxxxx
20952                                                              sqabs.  */
20953                                                           return 481;
20954                                                         }
20955                                                     }
20956                                                   else
20957                                                     {
20958                                                       /* 33222222222211111111110000000000
20959                                                          10987654321098765432109876543210
20960                                                          xx111110xx1xxxxx011110xxxxxxxxxx
20961                                                          sqneg.  */
20962                                                       return 510;
20963                                                     }
20964                                                 }
20965                                               else
20966                                                 {
20967                                                   if (((word >> 16) & 0x1) == 0)
20968                                                     {
20969                                                       if (((word >> 23) & 0x1) == 0)
20970                                                         {
20971                                                           if (((word >> 29) & 0x1) == 0)
20972                                                             {
20973                                                               /* 33222222222211111111110000000000
20974                                                                  10987654321098765432109876543210
20975                                                                  xx0111100x1xxxx0111110xxxxxxxxxx
20976                                                                  fmaxp.  */
20977                                                               return 543;
20978                                                             }
20979                                                           else
20980                                                             {
20981                                                               /* 33222222222211111111110000000000
20982                                                                  10987654321098765432109876543210
20983                                                                  xx1111100x1xxxx0111110xxxxxxxxxx
20984                                                                  fmaxp.  */
20985                                                               return 542;
20986                                                             }
20987                                                         }
20988                                                       else
20989                                                         {
20990                                                           if (((word >> 29) & 0x1) == 0)
20991                                                             {
20992                                                               /* 33222222222211111111110000000000
20993                                                                  10987654321098765432109876543210
20994                                                                  xx0111101x1xxxx0111110xxxxxxxxxx
20995                                                                  fminp.  */
20996                                                               return 547;
20997                                                             }
20998                                                           else
20999                                                             {
21000                                                               /* 33222222222211111111110000000000
21001                                                                  10987654321098765432109876543210
21002                                                                  xx1111101x1xxxx0111110xxxxxxxxxx
21003                                                                  fminp.  */
21004                                                               return 546;
21005                                                             }
21006                                                         }
21007                                                     }
21008                                                   else
21009                                                     {
21010                                                       if (((word >> 19) & 0x1) == 0)
21011                                                         {
21012                                                           /* 33222222222211111111110000000000
21013                                                              10987654321098765432109876543210
21014                                                              xxx11110xx1x0xx1111110xxxxxxxxxx
21015                                                              frecpx.  */
21016                                                           return 507;
21017                                                         }
21018                                                       else
21019                                                         {
21020                                                           /* 33222222222211111111110000000000
21021                                                              10987654321098765432109876543210
21022                                                              xxx11110xx1x1xx1111110xxxxxxxxxx
21023                                                              frecpx.  */
21024                                                           return 508;
21025                                                         }
21026                                                     }
21027                                                 }
21028                                             }
21029                                         }
21030                                     }
21031                                 }
21032                             }
21033                           else
21034                             {
21035                               if (((word >> 11) & 0x1) == 0)
21036                                 {
21037                                   if (((word >> 29) & 0x1) == 0)
21038                                     {
21039                                       if (((word >> 30) & 0x1) == 0)
21040                                         {
21041                                           if (((word >> 4) & 0x1) == 0)
21042                                             {
21043                                               /* 33222222222211111111110000000000
21044                                                  10987654321098765432109876543210
21045                                                  x0011110xx1xxxxxxxxx01xxxxx0xxxx
21046                                                  fccmp.  */
21047                                               return 798;
21048                                             }
21049                                           else
21050                                             {
21051                                               /* 33222222222211111111110000000000
21052                                                  10987654321098765432109876543210
21053                                                  x0011110xx1xxxxxxxxx01xxxxx1xxxx
21054                                                  fccmpe.  */
21055                                               return 800;
21056                                             }
21057                                         }
21058                                       else
21059                                         {
21060                                           if (((word >> 12) & 0x1) == 0)
21061                                             {
21062                                               if (((word >> 13) & 0x1) == 0)
21063                                                 {
21064                                                   if (((word >> 14) & 0x1) == 0)
21065                                                     {
21066                                                       /* 33222222222211111111110000000000
21067                                                          10987654321098765432109876543210
21068                                                          x1011110xx1xxxxxx00001xxxxxxxxxx
21069                                                          add.  */
21070                                                       return 565;
21071                                                     }
21072                                                   else
21073                                                     {
21074                                                       /* 33222222222211111111110000000000
21075                                                          10987654321098765432109876543210
21076                                                          x1011110xx1xxxxxx10001xxxxxxxxxx
21077                                                          sshl.  */
21078                                                       return 563;
21079                                                     }
21080                                                 }
21081                                               else
21082                                                 {
21083                                                   /* 33222222222211111111110000000000
21084                                                      10987654321098765432109876543210
21085                                                      x1011110xx1xxxxxxx1001xxxxxxxxxx
21086                                                      fcmeq.  */
21087                                                   return 555;
21088                                                 }
21089                                             }
21090                                           else
21091                                             {
21092                                               if (((word >> 13) & 0x1) == 0)
21093                                                 {
21094                                                   /* 33222222222211111111110000000000
21095                                                      10987654321098765432109876543210
21096                                                      x1011110xx1xxxxxxx0101xxxxxxxxxx
21097                                                      srshl.  */
21098                                                   return 564;
21099                                                 }
21100                                               else
21101                                                 {
21102                                                   if (((word >> 15) & 0x1) == 0)
21103                                                     {
21104                                                       /* 33222222222211111111110000000000
21105                                                          10987654321098765432109876543210
21106                                                          x1011110xx1xxxxx0x1101xxxxxxxxxx
21107                                                          cmgt.  */
21108                                                       return 561;
21109                                                     }
21110                                                   else
21111                                                     {
21112                                                       /* 33222222222211111111110000000000
21113                                                          10987654321098765432109876543210
21114                                                          x1011110xx1xxxxx1x1101xxxxxxxxxx
21115                                                          sqdmulh.  */
21116                                                       return 552;
21117                                                     }
21118                                                 }
21119                                             }
21120                                         }
21121                                     }
21122                                   else
21123                                     {
21124                                       if (((word >> 12) & 0x1) == 0)
21125                                         {
21126                                           if (((word >> 13) & 0x1) == 0)
21127                                             {
21128                                               if (((word >> 14) & 0x1) == 0)
21129                                                 {
21130                                                   /* 33222222222211111111110000000000
21131                                                      10987654321098765432109876543210
21132                                                      xx111110xx1xxxxxx00001xxxxxxxxxx
21133                                                      sub.  */
21134                                                   return 586;
21135                                                 }
21136                                               else
21137                                                 {
21138                                                   /* 33222222222211111111110000000000
21139                                                      10987654321098765432109876543210
21140                                                      xx111110xx1xxxxxx10001xxxxxxxxxx
21141                                                      ushl.  */
21142                                                   return 584;
21143                                                 }
21144                                             }
21145                                           else
21146                                             {
21147                                               if (((word >> 23) & 0x1) == 0)
21148                                                 {
21149                                                   /* 33222222222211111111110000000000
21150                                                      10987654321098765432109876543210
21151                                                      xx1111100x1xxxxxxx1001xxxxxxxxxx
21152                                                      fcmge.  */
21153                                                   return 572;
21154                                                 }
21155                                               else
21156                                                 {
21157                                                   /* 33222222222211111111110000000000
21158                                                      10987654321098765432109876543210
21159                                                      xx1111101x1xxxxxxx1001xxxxxxxxxx
21160                                                      fcmgt.  */
21161                                                   return 578;
21162                                                 }
21163                                             }
21164                                         }
21165                                       else
21166                                         {
21167                                           if (((word >> 13) & 0x1) == 0)
21168                                             {
21169                                               if (((word >> 15) & 0x1) == 0)
21170                                                 {
21171                                                   /* 33222222222211111111110000000000
21172                                                      10987654321098765432109876543210
21173                                                      xx111110xx1xxxxx0x0101xxxxxxxxxx
21174                                                      urshl.  */
21175                                                   return 585;
21176                                                 }
21177                                               else
21178                                                 {
21179                                                   /* 33222222222211111111110000000000
21180                                                      10987654321098765432109876543210
21181                                                      xx111110xx1xxxxx1x0101xxxxxxxxxx
21182                                                      fabd.  */
21183                                                   return 576;
21184                                                 }
21185                                             }
21186                                           else
21187                                             {
21188                                               if (((word >> 15) & 0x1) == 0)
21189                                                 {
21190                                                   /* 33222222222211111111110000000000
21191                                                      10987654321098765432109876543210
21192                                                      xx111110xx1xxxxx0x1101xxxxxxxxxx
21193                                                      cmhi.  */
21194                                                   return 582;
21195                                                 }
21196                                               else
21197                                                 {
21198                                                   /* 33222222222211111111110000000000
21199                                                      10987654321098765432109876543210
21200                                                      xx111110xx1xxxxx1x1101xxxxxxxxxx
21201                                                      sqrdmulh.  */
21202                                                   return 571;
21203                                                 }
21204                                             }
21205                                         }
21206                                     }
21207                                 }
21208                               else
21209                                 {
21210                                   if (((word >> 29) & 0x1) == 0)
21211                                     {
21212                                       if (((word >> 30) & 0x1) == 0)
21213                                         {
21214                                           /* 33222222222211111111110000000000
21215                                              10987654321098765432109876543210
21216                                              x0011110xx1xxxxxxxxx11xxxxxxxxxx
21217                                              fcsel.  */
21218                                           return 867;
21219                                         }
21220                                       else
21221                                         {
21222                                           if (((word >> 12) & 0x1) == 0)
21223                                             {
21224                                               if (((word >> 13) & 0x1) == 0)
21225                                                 {
21226                                                   if (((word >> 14) & 0x1) == 0)
21227                                                     {
21228                                                       if (((word >> 15) & 0x1) == 0)
21229                                                         {
21230                                                           /* 33222222222211111111110000000000
21231                                                              10987654321098765432109876543210
21232                                                              x1011110xx1xxxxx000011xxxxxxxxxx
21233                                                              sqadd.  */
21234                                                           return 548;
21235                                                         }
21236                                                       else
21237                                                         {
21238                                                           /* 33222222222211111111110000000000
21239                                                              10987654321098765432109876543210
21240                                                              x1011110xx1xxxxx100011xxxxxxxxxx
21241                                                              cmtst.  */
21242                                                           return 566;
21243                                                         }
21244                                                     }
21245                                                   else
21246                                                     {
21247                                                       /* 33222222222211111111110000000000
21248                                                          10987654321098765432109876543210
21249                                                          x1011110xx1xxxxxx10011xxxxxxxxxx
21250                                                          sqshl.  */
21251                                                       return 550;
21252                                                     }
21253                                                 }
21254                                               else
21255                                                 {
21256                                                   /* 33222222222211111111110000000000
21257                                                      10987654321098765432109876543210
21258                                                      x1011110xx1xxxxxxx1011xxxxxxxxxx
21259                                                      sqsub.  */
21260                                                   return 549;
21261                                                 }
21262                                             }
21263                                           else
21264                                             {
21265                                               if (((word >> 13) & 0x1) == 0)
21266                                                 {
21267                                                   if (((word >> 15) & 0x1) == 0)
21268                                                     {
21269                                                       /* 33222222222211111111110000000000
21270                                                          10987654321098765432109876543210
21271                                                          x1011110xx1xxxxx0x0111xxxxxxxxxx
21272                                                          sqrshl.  */
21273                                                       return 551;
21274                                                     }
21275                                                   else
21276                                                     {
21277                                                       /* 33222222222211111111110000000000
21278                                                          10987654321098765432109876543210
21279                                                          x1011110xx1xxxxx1x0111xxxxxxxxxx
21280                                                          fmulx.  */
21281                                                       return 553;
21282                                                     }
21283                                                 }
21284                                               else
21285                                                 {
21286                                                   if (((word >> 14) & 0x1) == 0)
21287                                                     {
21288                                                       /* 33222222222211111111110000000000
21289                                                          10987654321098765432109876543210
21290                                                          x1011110xx1xxxxxx01111xxxxxxxxxx
21291                                                          cmge.  */
21292                                                       return 562;
21293                                                     }
21294                                                   else
21295                                                     {
21296                                                       if (((word >> 23) & 0x1) == 0)
21297                                                         {
21298                                                           /* 33222222222211111111110000000000
21299                                                              10987654321098765432109876543210
21300                                                              x10111100x1xxxxxx11111xxxxxxxxxx
21301                                                              frecps.  */
21302                                                           return 557;
21303                                                         }
21304                                                       else
21305                                                         {
21306                                                           /* 33222222222211111111110000000000
21307                                                              10987654321098765432109876543210
21308                                                              x10111101x1xxxxxx11111xxxxxxxxxx
21309                                                              frsqrts.  */
21310                                                           return 559;
21311                                                         }
21312                                                     }
21313                                                 }
21314                                             }
21315                                         }
21316                                     }
21317                                   else
21318                                     {
21319                                       if (((word >> 12) & 0x1) == 0)
21320                                         {
21321                                           if (((word >> 13) & 0x1) == 0)
21322                                             {
21323                                               if (((word >> 14) & 0x1) == 0)
21324                                                 {
21325                                                   if (((word >> 15) & 0x1) == 0)
21326                                                     {
21327                                                       /* 33222222222211111111110000000000
21328                                                          10987654321098765432109876543210
21329                                                          xx111110xx1xxxxx000011xxxxxxxxxx
21330                                                          uqadd.  */
21331                                                       return 567;
21332                                                     }
21333                                                   else
21334                                                     {
21335                                                       /* 33222222222211111111110000000000
21336                                                          10987654321098765432109876543210
21337                                                          xx111110xx1xxxxx100011xxxxxxxxxx
21338                                                          cmeq.  */
21339                                                       return 587;
21340                                                     }
21341                                                 }
21342                                               else
21343                                                 {
21344                                                   /* 33222222222211111111110000000000
21345                                                      10987654321098765432109876543210
21346                                                      xx111110xx1xxxxxx10011xxxxxxxxxx
21347                                                      uqshl.  */
21348                                                   return 569;
21349                                                 }
21350                                             }
21351                                           else
21352                                             {
21353                                               if (((word >> 14) & 0x1) == 0)
21354                                                 {
21355                                                   /* 33222222222211111111110000000000
21356                                                      10987654321098765432109876543210
21357                                                      xx111110xx1xxxxxx01011xxxxxxxxxx
21358                                                      uqsub.  */
21359                                                   return 568;
21360                                                 }
21361                                               else
21362                                                 {
21363                                                   if (((word >> 23) & 0x1) == 0)
21364                                                     {
21365                                                       /* 33222222222211111111110000000000
21366                                                          10987654321098765432109876543210
21367                                                          xx1111100x1xxxxxx11011xxxxxxxxxx
21368                                                          facge.  */
21369                                                       return 574;
21370                                                     }
21371                                                   else
21372                                                     {
21373                                                       /* 33222222222211111111110000000000
21374                                                          10987654321098765432109876543210
21375                                                          xx1111101x1xxxxxx11011xxxxxxxxxx
21376                                                          facgt.  */
21377                                                       return 580;
21378                                                     }
21379                                                 }
21380                                             }
21381                                         }
21382                                       else
21383                                         {
21384                                           if (((word >> 13) & 0x1) == 0)
21385                                             {
21386                                               /* 33222222222211111111110000000000
21387                                                  10987654321098765432109876543210
21388                                                  xx111110xx1xxxxxxx0111xxxxxxxxxx
21389                                                  uqrshl.  */
21390                                               return 570;
21391                                             }
21392                                           else
21393                                             {
21394                                               /* 33222222222211111111110000000000
21395                                                  10987654321098765432109876543210
21396                                                  xx111110xx1xxxxxxx1111xxxxxxxxxx
21397                                                  cmhs.  */
21398                                               return 583;
21399                                             }
21400                                         }
21401                                     }
21402                                 }
21403                             }
21404                         }
21405                     }
21406                 }
21407               else
21408                 {
21409                   if (((word >> 15) & 0x1) == 0)
21410                     {
21411                       if (((word >> 28) & 0x1) == 0)
21412                         {
21413                           if (((word >> 10) & 0x1) == 0)
21414                             {
21415                               if (((word >> 12) & 0x1) == 0)
21416                                 {
21417                                   if (((word >> 13) & 0x1) == 0)
21418                                     {
21419                                       if (((word >> 14) & 0x1) == 0)
21420                                         {
21421                                           if (((word >> 29) & 0x1) == 0)
21422                                             {
21423                                               if (((word >> 30) & 0x1) == 0)
21424                                                 {
21425                                                   /* 33222222222211111111110000000000
21426                                                      10987654321098765432109876543210
21427                                                      x0001111xxxxxxxx0000x0xxxxxxxxxx
21428                                                      fmlal.  */
21429                                                   return 2365;
21430                                                 }
21431                                               else
21432                                                 {
21433                                                   /* 33222222222211111111110000000000
21434                                                      10987654321098765432109876543210
21435                                                      x1001111xxxxxxxx0000x0xxxxxxxxxx
21436                                                      fmlal.  */
21437                                                   return 2369;
21438                                                 }
21439                                             }
21440                                           else
21441                                             {
21442                                               /* 33222222222211111111110000000000
21443                                                  10987654321098765432109876543210
21444                                                  xx101111xxxxxxxx0000x0xxxxxxxxxx
21445                                                  mla.  */
21446                                               return 119;
21447                                             }
21448                                         }
21449                                       else
21450                                         {
21451                                           if (((word >> 29) & 0x1) == 0)
21452                                             {
21453                                               if (((word >> 30) & 0x1) == 0)
21454                                                 {
21455                                                   /* 33222222222211111111110000000000
21456                                                      10987654321098765432109876543210
21457                                                      x0001111xxxxxxxx0100x0xxxxxxxxxx
21458                                                      fmlsl.  */
21459                                                   return 2366;
21460                                                 }
21461                                               else
21462                                                 {
21463                                                   /* 33222222222211111111110000000000
21464                                                      10987654321098765432109876543210
21465                                                      x1001111xxxxxxxx0100x0xxxxxxxxxx
21466                                                      fmlsl.  */
21467                                                   return 2370;
21468                                                 }
21469                                             }
21470                                           else
21471                                             {
21472                                               /* 33222222222211111111110000000000
21473                                                  10987654321098765432109876543210
21474                                                  xx101111xxxxxxxx0100x0xxxxxxxxxx
21475                                                  mls.  */
21476                                               return 122;
21477                                             }
21478                                         }
21479                                     }
21480                                   else
21481                                     {
21482                                       if (((word >> 14) & 0x1) == 0)
21483                                         {
21484                                           if (((word >> 29) & 0x1) == 0)
21485                                             {
21486                                               if (((word >> 30) & 0x1) == 0)
21487                                                 {
21488                                                   /* 33222222222211111111110000000000
21489                                                      10987654321098765432109876543210
21490                                                      x0001111xxxxxxxx0010x0xxxxxxxxxx
21491                                                      smlal.  */
21492                                                   return 98;
21493                                                 }
21494                                               else
21495                                                 {
21496                                                   /* 33222222222211111111110000000000
21497                                                      10987654321098765432109876543210
21498                                                      x1001111xxxxxxxx0010x0xxxxxxxxxx
21499                                                      smlal2.  */
21500                                                   return 99;
21501                                                 }
21502                                             }
21503                                           else
21504                                             {
21505                                               if (((word >> 30) & 0x1) == 0)
21506                                                 {
21507                                                   /* 33222222222211111111110000000000
21508                                                      10987654321098765432109876543210
21509                                                      x0101111xxxxxxxx0010x0xxxxxxxxxx
21510                                                      umlal.  */
21511                                                   return 120;
21512                                                 }
21513                                               else
21514                                                 {
21515                                                   /* 33222222222211111111110000000000
21516                                                      10987654321098765432109876543210
21517                                                      x1101111xxxxxxxx0010x0xxxxxxxxxx
21518                                                      umlal2.  */
21519                                                   return 121;
21520                                                 }
21521                                             }
21522                                         }
21523                                       else
21524                                         {
21525                                           if (((word >> 29) & 0x1) == 0)
21526                                             {
21527                                               if (((word >> 30) & 0x1) == 0)
21528                                                 {
21529                                                   /* 33222222222211111111110000000000
21530                                                      10987654321098765432109876543210
21531                                                      x0001111xxxxxxxx0110x0xxxxxxxxxx
21532                                                      smlsl.  */
21533                                                   return 102;
21534                                                 }
21535                                               else
21536                                                 {
21537                                                   /* 33222222222211111111110000000000
21538                                                      10987654321098765432109876543210
21539                                                      x1001111xxxxxxxx0110x0xxxxxxxxxx
21540                                                      smlsl2.  */
21541                                                   return 103;
21542                                                 }
21543                                             }
21544                                           else
21545                                             {
21546                                               if (((word >> 30) & 0x1) == 0)
21547                                                 {
21548                                                   /* 33222222222211111111110000000000
21549                                                      10987654321098765432109876543210
21550                                                      x0101111xxxxxxxx0110x0xxxxxxxxxx
21551                                                      umlsl.  */
21552                                                   return 123;
21553                                                 }
21554                                               else
21555                                                 {
21556                                                   /* 33222222222211111111110000000000
21557                                                      10987654321098765432109876543210
21558                                                      x1101111xxxxxxxx0110x0xxxxxxxxxx
21559                                                      umlsl2.  */
21560                                                   return 124;
21561                                                 }
21562                                             }
21563                                         }
21564                                     }
21565                                 }
21566                               else
21567                                 {
21568                                   if (((word >> 29) & 0x1) == 0)
21569                                     {
21570                                       if (((word >> 13) & 0x1) == 0)
21571                                         {
21572                                           if (((word >> 14) & 0x1) == 0)
21573                                             {
21574                                               if (((word >> 23) & 0x1) == 0)
21575                                                 {
21576                                                   /* 33222222222211111111110000000000
21577                                                      10987654321098765432109876543210
21578                                                      xx0011110xxxxxxx0001x0xxxxxxxxxx
21579                                                      fmla.  */
21580                                                   return 114;
21581                                                 }
21582                                               else
21583                                                 {
21584                                                   /* 33222222222211111111110000000000
21585                                                      10987654321098765432109876543210
21586                                                      xx0011111xxxxxxx0001x0xxxxxxxxxx
21587                                                      fmla.  */
21588                                                   return 113;
21589                                                 }
21590                                             }
21591                                           else
21592                                             {
21593                                               if (((word >> 23) & 0x1) == 0)
21594                                                 {
21595                                                   /* 33222222222211111111110000000000
21596                                                      10987654321098765432109876543210
21597                                                      xx0011110xxxxxxx0101x0xxxxxxxxxx
21598                                                      fmls.  */
21599                                                   return 116;
21600                                                 }
21601                                               else
21602                                                 {
21603                                                   /* 33222222222211111111110000000000
21604                                                      10987654321098765432109876543210
21605                                                      xx0011111xxxxxxx0101x0xxxxxxxxxx
21606                                                      fmls.  */
21607                                                   return 115;
21608                                                 }
21609                                             }
21610                                         }
21611                                       else
21612                                         {
21613                                           if (((word >> 14) & 0x1) == 0)
21614                                             {
21615                                               if (((word >> 30) & 0x1) == 0)
21616                                                 {
21617                                                   /* 33222222222211111111110000000000
21618                                                      10987654321098765432109876543210
21619                                                      x0001111xxxxxxxx0011x0xxxxxxxxxx
21620                                                      sqdmlal.  */
21621                                                   return 100;
21622                                                 }
21623                                               else
21624                                                 {
21625                                                   /* 33222222222211111111110000000000
21626                                                      10987654321098765432109876543210
21627                                                      x1001111xxxxxxxx0011x0xxxxxxxxxx
21628                                                      sqdmlal2.  */
21629                                                   return 101;
21630                                                 }
21631                                             }
21632                                           else
21633                                             {
21634                                               if (((word >> 30) & 0x1) == 0)
21635                                                 {
21636                                                   /* 33222222222211111111110000000000
21637                                                      10987654321098765432109876543210
21638                                                      x0001111xxxxxxxx0111x0xxxxxxxxxx
21639                                                      sqdmlsl.  */
21640                                                   return 104;
21641                                                 }
21642                                               else
21643                                                 {
21644                                                   /* 33222222222211111111110000000000
21645                                                      10987654321098765432109876543210
21646                                                      x1001111xxxxxxxx0111x0xxxxxxxxxx
21647                                                      sqdmlsl2.  */
21648                                                   return 105;
21649                                                 }
21650                                             }
21651                                         }
21652                                     }
21653                                   else
21654                                     {
21655                                       /* 33222222222211111111110000000000
21656                                          10987654321098765432109876543210
21657                                          xx101111xxxxxxxx0xx1x0xxxxxxxxxx
21658                                          fcmla.  */
21659                                       return 131;
21660                                     }
21661                                 }
21662                             }
21663                           else
21664                             {
21665                               if (((word >> 12) & 0x1) == 0)
21666                                 {
21667                                   if (((word >> 29) & 0x1) == 0)
21668                                     {
21669                                       /* 33222222222211111111110000000000
21670                                          10987654321098765432109876543210
21671                                          xx001111xxxxxxxx0xx0x1xxxxxxxxxx
21672                                          movi.  */
21673                                       return 133;
21674                                     }
21675                                   else
21676                                     {
21677                                       /* 33222222222211111111110000000000
21678                                          10987654321098765432109876543210
21679                                          xx101111xxxxxxxx0xx0x1xxxxxxxxxx
21680                                          mvni.  */
21681                                       return 141;
21682                                     }
21683                                 }
21684                               else
21685                                 {
21686                                   if (((word >> 29) & 0x1) == 0)
21687                                     {
21688                                       /* 33222222222211111111110000000000
21689                                          10987654321098765432109876543210
21690                                          xx001111xxxxxxxx0xx1x1xxxxxxxxxx
21691                                          orr.  */
21692                                       return 134;
21693                                     }
21694                                   else
21695                                     {
21696                                       /* 33222222222211111111110000000000
21697                                          10987654321098765432109876543210
21698                                          xx101111xxxxxxxx0xx1x1xxxxxxxxxx
21699                                          bic.  */
21700                                       return 142;
21701                                     }
21702                                 }
21703                             }
21704                         }
21705                       else
21706                         {
21707                           if (((word >> 29) & 0x1) == 0)
21708                             {
21709                               if (((word >> 30) & 0x1) == 0)
21710                                 {
21711                                   if (((word >> 21) & 0x1) == 0)
21712                                     {
21713                                       /* 33222222222211111111110000000000
21714                                          10987654321098765432109876543210
21715                                          x0011111xx0xxxxx0xxxxxxxxxxxxxxx
21716                                          fmadd.  */
21717                                       return 857;
21718                                     }
21719                                   else
21720                                     {
21721                                       /* 33222222222211111111110000000000
21722                                          10987654321098765432109876543210
21723                                          x0011111xx1xxxxx0xxxxxxxxxxxxxxx
21724                                          fnmadd.  */
21725                                       return 861;
21726                                     }
21727                                 }
21728                               else
21729                                 {
21730                                   if (((word >> 10) & 0x1) == 0)
21731                                     {
21732                                       if (((word >> 13) & 0x1) == 0)
21733                                         {
21734                                           if (((word >> 14) & 0x1) == 0)
21735                                             {
21736                                               if (((word >> 23) & 0x1) == 0)
21737                                                 {
21738                                                   /* 33222222222211111111110000000000
21739                                                      10987654321098765432109876543210
21740                                                      x10111110xxxxxxx000xx0xxxxxxxxxx
21741                                                      fmla.  */
21742                                                   return 431;
21743                                                 }
21744                                               else
21745                                                 {
21746                                                   /* 33222222222211111111110000000000
21747                                                      10987654321098765432109876543210
21748                                                      x10111111xxxxxxx000xx0xxxxxxxxxx
21749                                                      fmla.  */
21750                                                   return 430;
21751                                                 }
21752                                             }
21753                                           else
21754                                             {
21755                                               if (((word >> 23) & 0x1) == 0)
21756                                                 {
21757                                                   /* 33222222222211111111110000000000
21758                                                      10987654321098765432109876543210
21759                                                      x10111110xxxxxxx010xx0xxxxxxxxxx
21760                                                      fmls.  */
21761                                                   return 433;
21762                                                 }
21763                                               else
21764                                                 {
21765                                                   /* 33222222222211111111110000000000
21766                                                      10987654321098765432109876543210
21767                                                      x10111111xxxxxxx010xx0xxxxxxxxxx
21768                                                      fmls.  */
21769                                                   return 432;
21770                                                 }
21771                                             }
21772                                         }
21773                                       else
21774                                         {
21775                                           if (((word >> 14) & 0x1) == 0)
21776                                             {
21777                                               /* 33222222222211111111110000000000
21778                                                  10987654321098765432109876543210
21779                                                  x1011111xxxxxxxx001xx0xxxxxxxxxx
21780                                                  sqdmlal.  */
21781                                               return 425;
21782                                             }
21783                                           else
21784                                             {
21785                                               /* 33222222222211111111110000000000
21786                                                  10987654321098765432109876543210
21787                                                  x1011111xxxxxxxx011xx0xxxxxxxxxx
21788                                                  sqdmlsl.  */
21789                                               return 426;
21790                                             }
21791                                         }
21792                                     }
21793                                   else
21794                                     {
21795                                       if (((word >> 12) & 0x1) == 0)
21796                                         {
21797                                           if (((word >> 13) & 0x1) == 0)
21798                                             {
21799                                               /* 33222222222211111111110000000000
21800                                                  10987654321098765432109876543210
21801                                                  x1011111xxxxxxxx0x00x1xxxxxxxxxx
21802                                                  sshr.  */
21803                                               return 590;
21804                                             }
21805                                           else
21806                                             {
21807                                               /* 33222222222211111111110000000000
21808                                                  10987654321098765432109876543210
21809                                                  x1011111xxxxxxxx0x10x1xxxxxxxxxx
21810                                                  srshr.  */
21811                                               return 592;
21812                                             }
21813                                         }
21814                                       else
21815                                         {
21816                                           if (((word >> 13) & 0x1) == 0)
21817                                             {
21818                                               if (((word >> 14) & 0x1) == 0)
21819                                                 {
21820                                                   /* 33222222222211111111110000000000
21821                                                      10987654321098765432109876543210
21822                                                      x1011111xxxxxxxx0001x1xxxxxxxxxx
21823                                                      ssra.  */
21824                                                   return 591;
21825                                                 }
21826                                               else
21827                                                 {
21828                                                   /* 33222222222211111111110000000000
21829                                                      10987654321098765432109876543210
21830                                                      x1011111xxxxxxxx0101x1xxxxxxxxxx
21831                                                      shl.  */
21832                                                   return 594;
21833                                                 }
21834                                             }
21835                                           else
21836                                             {
21837                                               if (((word >> 14) & 0x1) == 0)
21838                                                 {
21839                                                   /* 33222222222211111111110000000000
21840                                                      10987654321098765432109876543210
21841                                                      x1011111xxxxxxxx0011x1xxxxxxxxxx
21842                                                      srsra.  */
21843                                                   return 593;
21844                                                 }
21845                                               else
21846                                                 {
21847                                                   /* 33222222222211111111110000000000
21848                                                      10987654321098765432109876543210
21849                                                      x1011111xxxxxxxx0111x1xxxxxxxxxx
21850                                                      sqshl.  */
21851                                                   return 595;
21852                                                 }
21853                                             }
21854                                         }
21855                                     }
21856                                 }
21857                             }
21858                           else
21859                             {
21860                               if (((word >> 12) & 0x1) == 0)
21861                                 {
21862                                   if (((word >> 13) & 0x1) == 0)
21863                                     {
21864                                       if (((word >> 14) & 0x1) == 0)
21865                                         {
21866                                           /* 33222222222211111111110000000000
21867                                              10987654321098765432109876543210
21868                                              xx111111xxxxxxxx0000xxxxxxxxxxxx
21869                                              ushr.  */
21870                                           return 602;
21871                                         }
21872                                       else
21873                                         {
21874                                           /* 33222222222211111111110000000000
21875                                              10987654321098765432109876543210
21876                                              xx111111xxxxxxxx0100xxxxxxxxxxxx
21877                                              sri.  */
21878                                           return 606;
21879                                         }
21880                                     }
21881                                   else
21882                                     {
21883                                       if (((word >> 14) & 0x1) == 0)
21884                                         {
21885                                           /* 33222222222211111111110000000000
21886                                              10987654321098765432109876543210
21887                                              xx111111xxxxxxxx0010xxxxxxxxxxxx
21888                                              urshr.  */
21889                                           return 604;
21890                                         }
21891                                       else
21892                                         {
21893                                           /* 33222222222211111111110000000000
21894                                              10987654321098765432109876543210
21895                                              xx111111xxxxxxxx0110xxxxxxxxxxxx
21896                                              sqshlu.  */
21897                                           return 608;
21898                                         }
21899                                     }
21900                                 }
21901                               else
21902                                 {
21903                                   if (((word >> 13) & 0x1) == 0)
21904                                     {
21905                                       if (((word >> 14) & 0x1) == 0)
21906                                         {
21907                                           /* 33222222222211111111110000000000
21908                                              10987654321098765432109876543210
21909                                              xx111111xxxxxxxx0001xxxxxxxxxxxx
21910                                              usra.  */
21911                                           return 603;
21912                                         }
21913                                       else
21914                                         {
21915                                           /* 33222222222211111111110000000000
21916                                              10987654321098765432109876543210
21917                                              xx111111xxxxxxxx0101xxxxxxxxxxxx
21918                                              sli.  */
21919                                           return 607;
21920                                         }
21921                                     }
21922                                   else
21923                                     {
21924                                       if (((word >> 14) & 0x1) == 0)
21925                                         {
21926                                           /* 33222222222211111111110000000000
21927                                              10987654321098765432109876543210
21928                                              xx111111xxxxxxxx0011xxxxxxxxxxxx
21929                                              ursra.  */
21930                                           return 605;
21931                                         }
21932                                       else
21933                                         {
21934                                           /* 33222222222211111111110000000000
21935                                              10987654321098765432109876543210
21936                                              xx111111xxxxxxxx0111xxxxxxxxxxxx
21937                                              uqshl.  */
21938                                           return 609;
21939                                         }
21940                                     }
21941                                 }
21942                             }
21943                         }
21944                     }
21945                   else
21946                     {
21947                       if (((word >> 28) & 0x1) == 0)
21948                         {
21949                           if (((word >> 10) & 0x1) == 0)
21950                             {
21951                               if (((word >> 12) & 0x1) == 0)
21952                                 {
21953                                   if (((word >> 13) & 0x1) == 0)
21954                                     {
21955                                       if (((word >> 14) & 0x1) == 0)
21956                                         {
21957                                           if (((word >> 29) & 0x1) == 0)
21958                                             {
21959                                               /* 33222222222211111111110000000000
21960                                                  10987654321098765432109876543210
21961                                                  xx001111xxxxxxxx1000x0xxxxxxxxxx
21962                                                  mul.  */
21963                                               return 106;
21964                                             }
21965                                           else
21966                                             {
21967                                               if (((word >> 30) & 0x1) == 0)
21968                                                 {
21969                                                   /* 33222222222211111111110000000000
21970                                                      10987654321098765432109876543210
21971                                                      x0101111xxxxxxxx1000x0xxxxxxxxxx
21972                                                      fmlal2.  */
21973                                                   return 2367;
21974                                                 }
21975                                               else
21976                                                 {
21977                                                   /* 33222222222211111111110000000000
21978                                                      10987654321098765432109876543210
21979                                                      x1101111xxxxxxxx1000x0xxxxxxxxxx
21980                                                      fmlal2.  */
21981                                                   return 2371;
21982                                                 }
21983                                             }
21984                                         }
21985                                       else
21986                                         {
21987                                           if (((word >> 29) & 0x1) == 0)
21988                                             {
21989                                               /* 33222222222211111111110000000000
21990                                                  10987654321098765432109876543210
21991                                                  xx001111xxxxxxxx1100x0xxxxxxxxxx
21992                                                  sqdmulh.  */
21993                                               return 111;
21994                                             }
21995                                           else
21996                                             {
21997                                               if (((word >> 30) & 0x1) == 0)
21998                                                 {
21999                                                   /* 33222222222211111111110000000000
22000                                                      10987654321098765432109876543210
22001                                                      x0101111xxxxxxxx1100x0xxxxxxxxxx
22002                                                      fmlsl2.  */
22003                                                   return 2368;
22004                                                 }
22005                                               else
22006                                                 {
22007                                                   /* 33222222222211111111110000000000
22008                                                      10987654321098765432109876543210
22009                                                      x1101111xxxxxxxx1100x0xxxxxxxxxx
22010                                                      fmlsl2.  */
22011                                                   return 2372;
22012                                                 }
22013                                             }
22014                                         }
22015                                     }
22016                                   else
22017                                     {
22018                                       if (((word >> 14) & 0x1) == 0)
22019                                         {
22020                                           if (((word >> 29) & 0x1) == 0)
22021                                             {
22022                                               if (((word >> 30) & 0x1) == 0)
22023                                                 {
22024                                                   /* 33222222222211111111110000000000
22025                                                      10987654321098765432109876543210
22026                                                      x0001111xxxxxxxx1010x0xxxxxxxxxx
22027                                                      smull.  */
22028                                                   return 107;
22029                                                 }
22030                                               else
22031                                                 {
22032                                                   /* 33222222222211111111110000000000
22033                                                      10987654321098765432109876543210
22034                                                      x1001111xxxxxxxx1010x0xxxxxxxxxx
22035                                                      smull2.  */
22036                                                   return 108;
22037                                                 }
22038                                             }
22039                                           else
22040                                             {
22041                                               if (((word >> 30) & 0x1) == 0)
22042                                                 {
22043                                                   /* 33222222222211111111110000000000
22044                                                      10987654321098765432109876543210
22045                                                      x0101111xxxxxxxx1010x0xxxxxxxxxx
22046                                                      umull.  */
22047                                                   return 125;
22048                                                 }
22049                                               else
22050                                                 {
22051                                                   /* 33222222222211111111110000000000
22052                                                      10987654321098765432109876543210
22053                                                      x1101111xxxxxxxx1010x0xxxxxxxxxx
22054                                                      umull2.  */
22055                                                   return 126;
22056                                                 }
22057                                             }
22058                                         }
22059                                       else
22060                                         {
22061                                           if (((word >> 29) & 0x1) == 0)
22062                                             {
22063                                               /* 33222222222211111111110000000000
22064                                                  10987654321098765432109876543210
22065                                                  xx001111xxxxxxxx1110x0xxxxxxxxxx
22066                                                  sdot.  */
22067                                               return 2339;
22068                                             }
22069                                           else
22070                                             {
22071                                               /* 33222222222211111111110000000000
22072                                                  10987654321098765432109876543210
22073                                                  xx101111xxxxxxxx1110x0xxxxxxxxxx
22074                                                  udot.  */
22075                                               return 2338;
22076                                             }
22077                                         }
22078                                     }
22079                                 }
22080                               else
22081                                 {
22082                                   if (((word >> 13) & 0x1) == 0)
22083                                     {
22084                                       if (((word >> 14) & 0x1) == 0)
22085                                         {
22086                                           if (((word >> 23) & 0x1) == 0)
22087                                             {
22088                                               if (((word >> 29) & 0x1) == 0)
22089                                                 {
22090                                                   /* 33222222222211111111110000000000
22091                                                      10987654321098765432109876543210
22092                                                      xx0011110xxxxxxx1001x0xxxxxxxxxx
22093                                                      fmul.  */
22094                                                   return 118;
22095                                                 }
22096                                               else
22097                                                 {
22098                                                   /* 33222222222211111111110000000000
22099                                                      10987654321098765432109876543210
22100                                                      xx1011110xxxxxxx1001x0xxxxxxxxxx
22101                                                      fmulx.  */
22102                                                   return 128;
22103                                                 }
22104                                             }
22105                                           else
22106                                             {
22107                                               if (((word >> 29) & 0x1) == 0)
22108                                                 {
22109                                                   /* 33222222222211111111110000000000
22110                                                      10987654321098765432109876543210
22111                                                      xx0011111xxxxxxx1001x0xxxxxxxxxx
22112                                                      fmul.  */
22113                                                   return 117;
22114                                                 }
22115                                               else
22116                                                 {
22117                                                   /* 33222222222211111111110000000000
22118                                                      10987654321098765432109876543210
22119                                                      xx1011111xxxxxxx1001x0xxxxxxxxxx
22120                                                      fmulx.  */
22121                                                   return 127;
22122                                                 }
22123                                             }
22124                                         }
22125                                       else
22126                                         {
22127                                           if (((word >> 29) & 0x1) == 0)
22128                                             {
22129                                               /* 33222222222211111111110000000000
22130                                                  10987654321098765432109876543210
22131                                                  xx001111xxxxxxxx1101x0xxxxxxxxxx
22132                                                  sqrdmulh.  */
22133                                               return 112;
22134                                             }
22135                                           else
22136                                             {
22137                                               /* 33222222222211111111110000000000
22138                                                  10987654321098765432109876543210
22139                                                  xx101111xxxxxxxx1101x0xxxxxxxxxx
22140                                                  sqrdmlah.  */
22141                                               return 129;
22142                                             }
22143                                         }
22144                                     }
22145                                   else
22146                                     {
22147                                       if (((word >> 14) & 0x1) == 0)
22148                                         {
22149                                           if (((word >> 30) & 0x1) == 0)
22150                                             {
22151                                               /* 33222222222211111111110000000000
22152                                                  10987654321098765432109876543210
22153                                                  x0x01111xxxxxxxx1011x0xxxxxxxxxx
22154                                                  sqdmull.  */
22155                                               return 109;
22156                                             }
22157                                           else
22158                                             {
22159                                               /* 33222222222211111111110000000000
22160                                                  10987654321098765432109876543210
22161                                                  x1x01111xxxxxxxx1011x0xxxxxxxxxx
22162                                                  sqdmull2.  */
22163                                               return 110;
22164                                             }
22165                                         }
22166                                       else
22167                                         {
22168                                           /* 33222222222211111111110000000000
22169                                              10987654321098765432109876543210
22170                                              xxx01111xxxxxxxx1111x0xxxxxxxxxx
22171                                              sqrdmlsh.  */
22172                                           return 130;
22173                                         }
22174                                     }
22175                                 }
22176                             }
22177                           else
22178                             {
22179                               if (((word >> 11) & 0x1) == 0)
22180                                 {
22181                                   if (((word >> 14) & 0x1) == 0)
22182                                     {
22183                                       if (((word >> 12) & 0x1) == 0)
22184                                         {
22185                                           if (((word >> 29) & 0x1) == 0)
22186                                             {
22187                                               /* 33222222222211111111110000000000
22188                                                  10987654321098765432109876543210
22189                                                  xx001111xxxxxxxx10x001xxxxxxxxxx
22190                                                  movi.  */
22191                                               return 135;
22192                                             }
22193                                           else
22194                                             {
22195                                               /* 33222222222211111111110000000000
22196                                                  10987654321098765432109876543210
22197                                                  xx101111xxxxxxxx10x001xxxxxxxxxx
22198                                                  mvni.  */
22199                                               return 143;
22200                                             }
22201                                         }
22202                                       else
22203                                         {
22204                                           if (((word >> 29) & 0x1) == 0)
22205                                             {
22206                                               /* 33222222222211111111110000000000
22207                                                  10987654321098765432109876543210
22208                                                  xx001111xxxxxxxx10x101xxxxxxxxxx
22209                                                  orr.  */
22210                                               return 136;
22211                                             }
22212                                           else
22213                                             {
22214                                               /* 33222222222211111111110000000000
22215                                                  10987654321098765432109876543210
22216                                                  xx101111xxxxxxxx10x101xxxxxxxxxx
22217                                                  bic.  */
22218                                               return 144;
22219                                             }
22220                                         }
22221                                     }
22222                                   else
22223                                     {
22224                                       if (((word >> 13) & 0x1) == 0)
22225                                         {
22226                                           if (((word >> 29) & 0x1) == 0)
22227                                             {
22228                                               /* 33222222222211111111110000000000
22229                                                  10987654321098765432109876543210
22230                                                  xx001111xxxxxxxx110x01xxxxxxxxxx
22231                                                  movi.  */
22232                                               return 137;
22233                                             }
22234                                           else
22235                                             {
22236                                               /* 33222222222211111111110000000000
22237                                                  10987654321098765432109876543210
22238                                                  xx101111xxxxxxxx110x01xxxxxxxxxx
22239                                                  mvni.  */
22240                                               return 145;
22241                                             }
22242                                         }
22243                                       else
22244                                         {
22245                                           if (((word >> 12) & 0x1) == 0)
22246                                             {
22247                                               if (((word >> 29) & 0x1) == 0)
22248                                                 {
22249                                                   /* 33222222222211111111110000000000
22250                                                      10987654321098765432109876543210
22251                                                      xx001111xxxxxxxx111001xxxxxxxxxx
22252                                                      movi.  */
22253                                                   return 138;
22254                                                 }
22255                                               else
22256                                                 {
22257                                                   /* 33222222222211111111110000000000
22258                                                      10987654321098765432109876543210
22259                                                      xx101111xxxxxxxx111001xxxxxxxxxx
22260                                                      movi.  */
22261                                                   return 146;
22262                                                 }
22263                                             }
22264                                           else
22265                                             {
22266                                               if (((word >> 29) & 0x1) == 0)
22267                                                 {
22268                                                   /* 33222222222211111111110000000000
22269                                                      10987654321098765432109876543210
22270                                                      xx001111xxxxxxxx111101xxxxxxxxxx
22271                                                      fmov.  */
22272                                                   return 139;
22273                                                 }
22274                                               else
22275                                                 {
22276                                                   /* 33222222222211111111110000000000
22277                                                      10987654321098765432109876543210
22278                                                      xx101111xxxxxxxx111101xxxxxxxxxx
22279                                                      fmov.  */
22280                                                   return 148;
22281                                                 }
22282                                             }
22283                                         }
22284                                     }
22285                                 }
22286                               else
22287                                 {
22288                                   if (((word >> 12) & 0x1) == 0)
22289                                     {
22290                                       if (((word >> 29) & 0x1) == 0)
22291                                         {
22292                                           if (((word >> 30) & 0x1) == 0)
22293                                             {
22294                                               /* 33222222222211111111110000000000
22295                                                  10987654321098765432109876543210
22296                                                  x0001111xxxxxxxx1xx011xxxxxxxxxx
22297                                                  rshrn.  */
22298                                               return 382;
22299                                             }
22300                                           else
22301                                             {
22302                                               /* 33222222222211111111110000000000
22303                                                  10987654321098765432109876543210
22304                                                  x1001111xxxxxxxx1xx011xxxxxxxxxx
22305                                                  rshrn2.  */
22306                                               return 383;
22307                                             }
22308                                         }
22309                                       else
22310                                         {
22311                                           if (((word >> 30) & 0x1) == 0)
22312                                             {
22313                                               /* 33222222222211111111110000000000
22314                                                  10987654321098765432109876543210
22315                                                  x0101111xxxxxxxx1xx011xxxxxxxxxx
22316                                                  sqrshrun.  */
22317                                               return 406;
22318                                             }
22319                                           else
22320                                             {
22321                                               /* 33222222222211111111110000000000
22322                                                  10987654321098765432109876543210
22323                                                  x1101111xxxxxxxx1xx011xxxxxxxxxx
22324                                                  sqrshrun2.  */
22325                                               return 407;
22326                                             }
22327                                         }
22328                                     }
22329                                   else
22330                                     {
22331                                       if (((word >> 13) & 0x1) == 0)
22332                                         {
22333                                           if (((word >> 29) & 0x1) == 0)
22334                                             {
22335                                               if (((word >> 30) & 0x1) == 0)
22336                                                 {
22337                                                   /* 33222222222211111111110000000000
22338                                                      10987654321098765432109876543210
22339                                                      x0001111xxxxxxxx1x0111xxxxxxxxxx
22340                                                      sqrshrn.  */
22341                                                   return 386;
22342                                                 }
22343                                               else
22344                                                 {
22345                                                   /* 33222222222211111111110000000000
22346                                                      10987654321098765432109876543210
22347                                                      x1001111xxxxxxxx1x0111xxxxxxxxxx
22348                                                      sqrshrn2.  */
22349                                                   return 387;
22350                                                 }
22351                                             }
22352                                           else
22353                                             {
22354                                               if (((word >> 30) & 0x1) == 0)
22355                                                 {
22356                                                   /* 33222222222211111111110000000000
22357                                                      10987654321098765432109876543210
22358                                                      x0101111xxxxxxxx1x0111xxxxxxxxxx
22359                                                      uqrshrn.  */
22360                                                   return 410;
22361                                                 }
22362                                               else
22363                                                 {
22364                                                   /* 33222222222211111111110000000000
22365                                                      10987654321098765432109876543210
22366                                                      x1101111xxxxxxxx1x0111xxxxxxxxxx
22367                                                      uqrshrn2.  */
22368                                                   return 411;
22369                                                 }
22370                                             }
22371                                         }
22372                                       else
22373                                         {
22374                                           if (((word >> 29) & 0x1) == 0)
22375                                             {
22376                                               /* 33222222222211111111110000000000
22377                                                  10987654321098765432109876543210
22378                                                  xx001111xxxxxxxx1x1111xxxxxxxxxx
22379                                                  fmov.  */
22380                                               return 140;
22381                                             }
22382                                           else
22383                                             {
22384                                               /* 33222222222211111111110000000000
22385                                                  10987654321098765432109876543210
22386                                                  xx101111xxxxxxxx1x1111xxxxxxxxxx
22387                                                  fcvtzu.  */
22388                                               return 418;
22389                                             }
22390                                         }
22391                                     }
22392                                 }
22393                             }
22394                         }
22395                       else
22396                         {
22397                           if (((word >> 29) & 0x1) == 0)
22398                             {
22399                               if (((word >> 30) & 0x1) == 0)
22400                                 {
22401                                   if (((word >> 21) & 0x1) == 0)
22402                                     {
22403                                       /* 33222222222211111111110000000000
22404                                          10987654321098765432109876543210
22405                                          x0011111xx0xxxxx1xxxxxxxxxxxxxxx
22406                                          fmsub.  */
22407                                       return 859;
22408                                     }
22409                                   else
22410                                     {
22411                                       /* 33222222222211111111110000000000
22412                                          10987654321098765432109876543210
22413                                          x0011111xx1xxxxx1xxxxxxxxxxxxxxx
22414                                          fnmsub.  */
22415                                       return 863;
22416                                     }
22417                                 }
22418                               else
22419                                 {
22420                                   if (((word >> 10) & 0x1) == 0)
22421                                     {
22422                                       if (((word >> 12) & 0x1) == 0)
22423                                         {
22424                                           /* 33222222222211111111110000000000
22425                                              10987654321098765432109876543210
22426                                              x1011111xxxxxxxx1xx0x0xxxxxxxxxx
22427                                              sqdmulh.  */
22428                                           return 428;
22429                                         }
22430                                       else
22431                                         {
22432                                           if (((word >> 13) & 0x1) == 0)
22433                                             {
22434                                               if (((word >> 14) & 0x1) == 0)
22435                                                 {
22436                                                   if (((word >> 23) & 0x1) == 0)
22437                                                     {
22438                                                       /* 33222222222211111111110000000000
22439                                                          10987654321098765432109876543210
22440                                                          x10111110xxxxxxx1001x0xxxxxxxxxx
22441                                                          fmul.  */
22442                                                       return 435;
22443                                                     }
22444                                                   else
22445                                                     {
22446                                                       /* 33222222222211111111110000000000
22447                                                          10987654321098765432109876543210
22448                                                          x10111111xxxxxxx1001x0xxxxxxxxxx
22449                                                          fmul.  */
22450                                                       return 434;
22451                                                     }
22452                                                 }
22453                                               else
22454                                                 {
22455                                                   /* 33222222222211111111110000000000
22456                                                      10987654321098765432109876543210
22457                                                      x1011111xxxxxxxx1101x0xxxxxxxxxx
22458                                                      sqrdmulh.  */
22459                                                   return 429;
22460                                                 }
22461                                             }
22462                                           else
22463                                             {
22464                                               /* 33222222222211111111110000000000
22465                                                  10987654321098765432109876543210
22466                                                  x1011111xxxxxxxx1x11x0xxxxxxxxxx
22467                                                  sqdmull.  */
22468                                               return 427;
22469                                             }
22470                                         }
22471                                     }
22472                                   else
22473                                     {
22474                                       if (((word >> 11) & 0x1) == 0)
22475                                         {
22476                                           if (((word >> 12) & 0x1) == 0)
22477                                             {
22478                                               /* 33222222222211111111110000000000
22479                                                  10987654321098765432109876543210
22480                                                  x1011111xxxxxxxx1xx001xxxxxxxxxx
22481                                                  scvtf.  */
22482                                               return 598;
22483                                             }
22484                                           else
22485                                             {
22486                                               /* 33222222222211111111110000000000
22487                                                  10987654321098765432109876543210
22488                                                  x1011111xxxxxxxx1xx101xxxxxxxxxx
22489                                                  sqshrn.  */
22490                                               return 596;
22491                                             }
22492                                         }
22493                                       else
22494                                         {
22495                                           if (((word >> 13) & 0x1) == 0)
22496                                             {
22497                                               /* 33222222222211111111110000000000
22498                                                  10987654321098765432109876543210
22499                                                  x1011111xxxxxxxx1x0x11xxxxxxxxxx
22500                                                  sqrshrn.  */
22501                                               return 597;
22502                                             }
22503                                           else
22504                                             {
22505                                               /* 33222222222211111111110000000000
22506                                                  10987654321098765432109876543210
22507                                                  x1011111xxxxxxxx1x1x11xxxxxxxxxx
22508                                                  fcvtzs.  */
22509                                               return 600;
22510                                             }
22511                                         }
22512                                     }
22513                                 }
22514                             }
22515                           else
22516                             {
22517                               if (((word >> 10) & 0x1) == 0)
22518                                 {
22519                                   if (((word >> 13) & 0x1) == 0)
22520                                     {
22521                                       if (((word >> 14) & 0x1) == 0)
22522                                         {
22523                                           if (((word >> 23) & 0x1) == 0)
22524                                             {
22525                                               /* 33222222222211111111110000000000
22526                                                  10987654321098765432109876543210
22527                                                  xx1111110xxxxxxx100xx0xxxxxxxxxx
22528                                                  fmulx.  */
22529                                               return 437;
22530                                             }
22531                                           else
22532                                             {
22533                                               /* 33222222222211111111110000000000
22534                                                  10987654321098765432109876543210
22535                                                  xx1111111xxxxxxx100xx0xxxxxxxxxx
22536                                                  fmulx.  */
22537                                               return 436;
22538                                             }
22539                                         }
22540                                       else
22541                                         {
22542                                           /* 33222222222211111111110000000000
22543                                              10987654321098765432109876543210
22544                                              xx111111xxxxxxxx110xx0xxxxxxxxxx
22545                                              sqrdmlah.  */
22546                                           return 438;
22547                                         }
22548                                     }
22549                                   else
22550                                     {
22551                                       /* 33222222222211111111110000000000
22552                                          10987654321098765432109876543210
22553                                          xx111111xxxxxxxx1x1xx0xxxxxxxxxx
22554                                          sqrdmlsh.  */
22555                                       return 439;
22556                                     }
22557                                 }
22558                               else
22559                                 {
22560                                   if (((word >> 11) & 0x1) == 0)
22561                                     {
22562                                       if (((word >> 12) & 0x1) == 0)
22563                                         {
22564                                           if (((word >> 13) & 0x1) == 0)
22565                                             {
22566                                               /* 33222222222211111111110000000000
22567                                                  10987654321098765432109876543210
22568                                                  xx111111xxxxxxxx1x0001xxxxxxxxxx
22569                                                  sqshrun.  */
22570                                               return 610;
22571                                             }
22572                                           else
22573                                             {
22574                                               /* 33222222222211111111110000000000
22575                                                  10987654321098765432109876543210
22576                                                  xx111111xxxxxxxx1x1001xxxxxxxxxx
22577                                                  ucvtf.  */
22578                                               return 614;
22579                                             }
22580                                         }
22581                                       else
22582                                         {
22583                                           /* 33222222222211111111110000000000
22584                                              10987654321098765432109876543210
22585                                              xx111111xxxxxxxx1xx101xxxxxxxxxx
22586                                              uqshrn.  */
22587                                           return 612;
22588                                         }
22589                                     }
22590                                   else
22591                                     {
22592                                       if (((word >> 12) & 0x1) == 0)
22593                                         {
22594                                           /* 33222222222211111111110000000000
22595                                              10987654321098765432109876543210
22596                                              xx111111xxxxxxxx1xx011xxxxxxxxxx
22597                                              sqrshrun.  */
22598                                           return 611;
22599                                         }
22600                                       else
22601                                         {
22602                                           if (((word >> 13) & 0x1) == 0)
22603                                             {
22604                                               /* 33222222222211111111110000000000
22605                                                  10987654321098765432109876543210
22606                                                  xx111111xxxxxxxx1x0111xxxxxxxxxx
22607                                                  uqrshrn.  */
22608                                               return 613;
22609                                             }
22610                                           else
22611                                             {
22612                                               /* 33222222222211111111110000000000
22613                                                  10987654321098765432109876543210
22614                                                  xx111111xxxxxxxx1x1111xxxxxxxxxx
22615                                                  fcvtzu.  */
22616                                               return 616;
22617                                             }
22618                                         }
22619                                     }
22620                                 }
22621                             }
22622                         }
22623                     }
22624                 }
22625             }
22626         }
22627     }
22628 }
22629
22630 /* Lookup opcode WORD in the opcode table.  N.B. all alias
22631    opcodes are ignored here.  */
22632
22633 const aarch64_opcode *
22634 aarch64_opcode_lookup (uint32_t word)
22635 {
22636   return aarch64_opcode_table + aarch64_opcode_lookup_1 (word);
22637 }
22638
22639 const aarch64_opcode *
22640 aarch64_find_next_opcode (const aarch64_opcode *opcode)
22641 {
22642   /* Use the index as the key to locate the next opcode.  */
22643   int key = opcode - aarch64_opcode_table;
22644   int value;
22645   switch (key)
22646     {
22647     case 12: value = 19; break; /* add --> addg.  */
22648     case 19: return NULL;               /* addg --> NULL.  */
22649     case 16: value = 20; break; /* sub --> subg.  */
22650     case 20: return NULL;               /* subg --> NULL.  */
22651     case 970: value = 974; break;       /* stnp --> stp.  */
22652     case 974: return NULL;              /* stp --> NULL.  */
22653     case 968: value = 969; break;       /* stllrb --> stllrh.  */
22654     case 969: return NULL;              /* stllrh --> NULL.  */
22655     case 971: value = 975; break;       /* ldnp --> ldp.  */
22656     case 975: return NULL;              /* ldp --> NULL.  */
22657     case 1624: value = 1625; break;     /* ldff1b --> ldff1b.  */
22658     case 1625: return NULL;             /* ldff1b --> NULL.  */
22659     case 1680: value = 1681; break;     /* ldff1sw --> ldff1sw.  */
22660     case 1681: return NULL;             /* ldff1sw --> NULL.  */
22661     case 1628: value = 1629; break;     /* ldff1b --> ldff1b.  */
22662     case 1629: return NULL;             /* ldff1b --> NULL.  */
22663     case 1647: value = 1648; break;     /* ldff1h --> ldff1h.  */
22664     case 1648: return NULL;             /* ldff1h --> NULL.  */
22665     case 1626: value = 1627; break;     /* ldff1b --> ldff1b.  */
22666     case 1627: return NULL;             /* ldff1b --> NULL.  */
22667     case 1645: value = 1646; break;     /* ldff1h --> ldff1h.  */
22668     case 1646: return NULL;             /* ldff1h --> NULL.  */
22669     case 1630: value = 1631; break;     /* ldff1b --> ldff1b.  */
22670     case 1631: return NULL;             /* ldff1b --> NULL.  */
22671     case 1649: value = 1650; break;     /* ldff1h --> ldff1h.  */
22672     case 1650: return NULL;             /* ldff1h --> NULL.  */
22673     case 1670: value = 1671; break;     /* ldff1sh --> ldff1sh.  */
22674     case 1671: return NULL;             /* ldff1sh --> NULL.  */
22675     case 1658: value = 1659; break;     /* ldff1sb --> ldff1sb.  */
22676     case 1659: return NULL;             /* ldff1sb --> NULL.  */
22677     case 1689: value = 1690; break;     /* ldff1w --> ldff1w.  */
22678     case 1690: return NULL;             /* ldff1w --> NULL.  */
22679     case 1662: value = 1663; break;     /* ldff1sb --> ldff1sb.  */
22680     case 1663: return NULL;             /* ldff1sb --> NULL.  */
22681     case 1672: value = 1673; break;     /* ldff1sh --> ldff1sh.  */
22682     case 1673: return NULL;             /* ldff1sh --> NULL.  */
22683     case 1660: value = 1661; break;     /* ldff1sb --> ldff1sb.  */
22684     case 1661: return NULL;             /* ldff1sb --> NULL.  */
22685     case 1691: value = 1692; break;     /* ldff1w --> ldff1w.  */
22686     case 1692: return NULL;             /* ldff1w --> NULL.  */
22687     case 1636: value = 1637; break;     /* ldff1d --> ldff1d.  */
22688     case 1637: return NULL;             /* ldff1d --> NULL.  */
22689     case 810: value = 811; break;       /* xaflag --> axflag.  */
22690     case 811: value = 1189; break;      /* axflag --> tcommit.  */
22691     case 1189: value = 1192; break;     /* tcommit --> msr.  */
22692     case 1192: value = 1193; break;     /* msr --> hint.  */
22693     case 1193: value = 1209; break;     /* hint --> clrex.  */
22694     case 1209: value = 1210; break;     /* clrex --> dsb.  */
22695     case 1210: value = 1213; break;     /* dsb --> dmb.  */
22696     case 1213: value = 1214; break;     /* dmb --> isb.  */
22697     case 1214: value = 1215; break;     /* isb --> sb.  */
22698     case 1215: value = 1216; break;     /* sb --> sys.  */
22699     case 1216: value = 1224; break;     /* sys --> msr.  */
22700     case 1224: value = 2373; break;     /* msr --> cfinv.  */
22701     case 2373: return NULL;             /* cfinv --> NULL.  */
22702     case 1188: value = 1190; break;     /* tstart --> ttest.  */
22703     case 1190: value = 1225; break;     /* ttest --> sysl.  */
22704     case 1225: value = 1226; break;     /* sysl --> mrs.  */
22705     case 1226: return NULL;             /* mrs --> NULL.  */
22706     case 440: value = 441; break;       /* st4 --> st1.  */
22707     case 441: value = 442; break;       /* st1 --> st2.  */
22708     case 442: value = 443; break;       /* st2 --> st3.  */
22709     case 443: return NULL;              /* st3 --> NULL.  */
22710     case 448: value = 449; break;       /* st4 --> st1.  */
22711     case 449: value = 450; break;       /* st1 --> st2.  */
22712     case 450: value = 451; break;       /* st2 --> st3.  */
22713     case 451: return NULL;              /* st3 --> NULL.  */
22714     case 444: value = 445; break;       /* ld4 --> ld1.  */
22715     case 445: value = 446; break;       /* ld1 --> ld2.  */
22716     case 446: value = 447; break;       /* ld2 --> ld3.  */
22717     case 447: return NULL;              /* ld3 --> NULL.  */
22718     case 460: value = 462; break;       /* ld1 --> ld1r.  */
22719     case 462: return NULL;              /* ld1r --> NULL.  */
22720     case 464: value = 466; break;       /* ld2 --> ld2r.  */
22721     case 466: return NULL;              /* ld2r --> NULL.  */
22722     case 461: value = 463; break;       /* ld3 --> ld3r.  */
22723     case 463: return NULL;              /* ld3r --> NULL.  */
22724     case 465: value = 467; break;       /* ld4 --> ld4r.  */
22725     case 467: return NULL;              /* ld4r --> NULL.  */
22726     case 452: value = 453; break;       /* ld4 --> ld1.  */
22727     case 453: value = 454; break;       /* ld1 --> ld2.  */
22728     case 454: value = 455; break;       /* ld2 --> ld3.  */
22729     case 455: return NULL;              /* ld3 --> NULL.  */
22730     case 472: value = 474; break;       /* ld1 --> ld1r.  */
22731     case 474: return NULL;              /* ld1r --> NULL.  */
22732     case 473: value = 475; break;       /* ld3 --> ld3r.  */
22733     case 475: return NULL;              /* ld3r --> NULL.  */
22734     case 476: value = 478; break;       /* ld2 --> ld2r.  */
22735     case 478: return NULL;              /* ld2r --> NULL.  */
22736     case 477: value = 479; break;       /* ld4 --> ld4r.  */
22737     case 479: return NULL;              /* ld4r --> NULL.  */
22738     case 763: value = 764; break;       /* fcvtzs --> fcvtzs.  */
22739     case 764: return NULL;              /* fcvtzs --> NULL.  */
22740     case 759: value = 760; break;       /* scvtf --> scvtf.  */
22741     case 760: return NULL;              /* scvtf --> NULL.  */
22742     case 765: value = 766; break;       /* fcvtzu --> fcvtzu.  */
22743     case 766: return NULL;              /* fcvtzu --> NULL.  */
22744     case 761: value = 762; break;       /* ucvtf --> ucvtf.  */
22745     case 762: return NULL;              /* ucvtf --> NULL.  */
22746     case 767: value = 768; break;       /* fcvtns --> fcvtns.  */
22747     case 768: return NULL;              /* fcvtns --> NULL.  */
22748     case 787: value = 788; break;       /* fcvtms --> fcvtms.  */
22749     case 788: return NULL;              /* fcvtms --> NULL.  */
22750     case 783: value = 784; break;       /* fcvtps --> fcvtps.  */
22751     case 784: return NULL;              /* fcvtps --> NULL.  */
22752     case 791: value = 792; break;       /* fcvtzs --> fcvtzs.  */
22753     case 792: return NULL;              /* fcvtzs --> NULL.  */
22754     case 775: value = 776; break;       /* fcvtas --> fcvtas.  */
22755     case 776: return NULL;              /* fcvtas --> NULL.  */
22756     case 771: value = 772; break;       /* scvtf --> scvtf.  */
22757     case 772: return NULL;              /* scvtf --> NULL.  */
22758     case 779: value = 780; break;       /* fmov --> fmov.  */
22759     case 780: return NULL;              /* fmov --> NULL.  */
22760     case 769: value = 770; break;       /* fcvtnu --> fcvtnu.  */
22761     case 770: return NULL;              /* fcvtnu --> NULL.  */
22762     case 789: value = 790; break;       /* fcvtmu --> fcvtmu.  */
22763     case 790: return NULL;              /* fcvtmu --> NULL.  */
22764     case 785: value = 786; break;       /* fcvtpu --> fcvtpu.  */
22765     case 786: return NULL;              /* fcvtpu --> NULL.  */
22766     case 793: value = 794; break;       /* fcvtzu --> fcvtzu.  */
22767     case 794: return NULL;              /* fcvtzu --> NULL.  */
22768     case 777: value = 778; break;       /* fcvtau --> fcvtau.  */
22769     case 778: return NULL;              /* fcvtau --> NULL.  */
22770     case 773: value = 774; break;       /* ucvtf --> ucvtf.  */
22771     case 774: return NULL;              /* ucvtf --> NULL.  */
22772     case 781: value = 782; break;       /* fmov --> fmov.  */
22773     case 782: return NULL;              /* fmov --> NULL.  */
22774     case 816: value = 817; break;       /* fmov --> fmov.  */
22775     case 817: return NULL;              /* fmov --> NULL.  */
22776     case 825: value = 826; break;       /* frintn --> frintn.  */
22777     case 826: return NULL;              /* frintn --> NULL.  */
22778     case 820: value = 821; break;       /* fneg --> fneg.  */
22779     case 821: return NULL;              /* fneg --> NULL.  */
22780     case 829: value = 830; break;       /* frintm --> frintm.  */
22781     case 830: return NULL;              /* frintm --> NULL.  */
22782     case 818: value = 819; break;       /* fabs --> fabs.  */
22783     case 819: return NULL;              /* fabs --> NULL.  */
22784     case 827: value = 828; break;       /* frintp --> frintp.  */
22785     case 828: return NULL;              /* frintp --> NULL.  */
22786     case 822: value = 823; break;       /* fsqrt --> fsqrt.  */
22787     case 823: return NULL;              /* fsqrt --> NULL.  */
22788     case 831: value = 832; break;       /* frintz --> frintz.  */
22789     case 832: return NULL;              /* frintz --> NULL.  */
22790     case 833: value = 834; break;       /* frinta --> frinta.  */
22791     case 834: return NULL;              /* frinta --> NULL.  */
22792     case 835: value = 836; break;       /* frintx --> frintx.  */
22793     case 836: return NULL;              /* frintx --> NULL.  */
22794     case 837: value = 838; break;       /* frinti --> frinti.  */
22795     case 838: return NULL;              /* frinti --> NULL.  */
22796     case 802: value = 803; break;       /* fcmp --> fcmp.  */
22797     case 803: return NULL;              /* fcmp --> NULL.  */
22798     case 804: value = 805; break;       /* fcmpe --> fcmpe.  */
22799     case 805: return NULL;              /* fcmpe --> NULL.  */
22800     case 806: value = 807; break;       /* fcmp --> fcmp.  */
22801     case 807: return NULL;              /* fcmp --> NULL.  */
22802     case 808: value = 809; break;       /* fcmpe --> fcmpe.  */
22803     case 809: return NULL;              /* fcmpe --> NULL.  */
22804     case 865: value = 866; break;       /* fmov --> fmov.  */
22805     case 866: return NULL;              /* fmov --> NULL.  */
22806     case 839: value = 840; break;       /* fmul --> fmul.  */
22807     case 840: return NULL;              /* fmul --> NULL.  */
22808     case 855: value = 856; break;       /* fnmul --> fnmul.  */
22809     case 856: return NULL;              /* fnmul --> NULL.  */
22810     case 847: value = 848; break;       /* fmax --> fmax.  */
22811     case 848: return NULL;              /* fmax --> NULL.  */
22812     case 843: value = 844; break;       /* fadd --> fadd.  */
22813     case 844: return NULL;              /* fadd --> NULL.  */
22814     case 851: value = 852; break;       /* fmaxnm --> fmaxnm.  */
22815     case 852: return NULL;              /* fmaxnm --> NULL.  */
22816     case 841: value = 842; break;       /* fdiv --> fdiv.  */
22817     case 842: return NULL;              /* fdiv --> NULL.  */
22818     case 849: value = 850; break;       /* fmin --> fmin.  */
22819     case 850: return NULL;              /* fmin --> NULL.  */
22820     case 845: value = 846; break;       /* fsub --> fsub.  */
22821     case 846: return NULL;              /* fsub --> NULL.  */
22822     case 853: value = 854; break;       /* fminnm --> fminnm.  */
22823     case 854: return NULL;              /* fminnm --> NULL.  */
22824     case 798: value = 799; break;       /* fccmp --> fccmp.  */
22825     case 799: return NULL;              /* fccmp --> NULL.  */
22826     case 800: value = 801; break;       /* fccmpe --> fccmpe.  */
22827     case 801: return NULL;              /* fccmpe --> NULL.  */
22828     case 867: value = 868; break;       /* fcsel --> fcsel.  */
22829     case 868: return NULL;              /* fcsel --> NULL.  */
22830     case 133: value = 374; break;       /* movi --> sshr.  */
22831     case 374: value = 376; break;       /* sshr --> srshr.  */
22832     case 376: return NULL;              /* srshr --> NULL.  */
22833     case 141: value = 396; break;       /* mvni --> ushr.  */
22834     case 396: value = 398; break;       /* ushr --> urshr.  */
22835     case 398: value = 400; break;       /* urshr --> sri.  */
22836     case 400: value = 402; break;       /* sri --> sqshlu.  */
22837     case 402: return NULL;              /* sqshlu --> NULL.  */
22838     case 134: value = 375; break;       /* orr --> ssra.  */
22839     case 375: value = 377; break;       /* ssra --> srsra.  */
22840     case 377: value = 378; break;       /* srsra --> shl.  */
22841     case 378: value = 379; break;       /* shl --> sqshl.  */
22842     case 379: return NULL;              /* sqshl --> NULL.  */
22843     case 142: value = 397; break;       /* bic --> usra.  */
22844     case 397: value = 399; break;       /* usra --> ursra.  */
22845     case 399: value = 401; break;       /* ursra --> sli.  */
22846     case 401: value = 403; break;       /* sli --> uqshl.  */
22847     case 403: return NULL;              /* uqshl --> NULL.  */
22848     case 857: value = 858; break;       /* fmadd --> fmadd.  */
22849     case 858: return NULL;              /* fmadd --> NULL.  */
22850     case 861: value = 862; break;       /* fnmadd --> fnmadd.  */
22851     case 862: return NULL;              /* fnmadd --> NULL.  */
22852     case 135: value = 380; break;       /* movi --> shrn.  */
22853     case 380: value = 381; break;       /* shrn --> shrn2.  */
22854     case 381: value = 388; break;       /* shrn2 --> sshll.  */
22855     case 388: value = 390; break;       /* sshll --> sshll2.  */
22856     case 390: return NULL;              /* sshll2 --> NULL.  */
22857     case 143: value = 404; break;       /* mvni --> sqshrun.  */
22858     case 404: value = 405; break;       /* sqshrun --> sqshrun2.  */
22859     case 405: value = 412; break;       /* sqshrun2 --> ushll.  */
22860     case 412: value = 414; break;       /* ushll --> ushll2.  */
22861     case 414: return NULL;              /* ushll2 --> NULL.  */
22862     case 136: value = 384; break;       /* orr --> sqshrn.  */
22863     case 384: value = 385; break;       /* sqshrn --> sqshrn2.  */
22864     case 385: return NULL;              /* sqshrn2 --> NULL.  */
22865     case 144: value = 408; break;       /* bic --> uqshrn.  */
22866     case 408: value = 409; break;       /* uqshrn --> uqshrn2.  */
22867     case 409: return NULL;              /* uqshrn2 --> NULL.  */
22868     case 138: value = 392; break;       /* movi --> scvtf.  */
22869     case 392: value = 393; break;       /* scvtf --> scvtf.  */
22870     case 393: return NULL;              /* scvtf --> NULL.  */
22871     case 146: value = 147; break;       /* movi --> movi.  */
22872     case 147: value = 416; break;       /* movi --> ucvtf.  */
22873     case 416: value = 417; break;       /* ucvtf --> ucvtf.  */
22874     case 417: return NULL;              /* ucvtf --> NULL.  */
22875     case 140: value = 394; break;       /* fmov --> fcvtzs.  */
22876     case 394: value = 395; break;       /* fcvtzs --> fcvtzs.  */
22877     case 395: return NULL;              /* fcvtzs --> NULL.  */
22878     case 418: value = 419; break;       /* fcvtzu --> fcvtzu.  */
22879     case 419: return NULL;              /* fcvtzu --> NULL.  */
22880     case 859: value = 860; break;       /* fmsub --> fmsub.  */
22881     case 860: return NULL;              /* fmsub --> NULL.  */
22882     case 863: value = 864; break;       /* fnmsub --> fnmsub.  */
22883     case 864: return NULL;              /* fnmsub --> NULL.  */
22884     case 598: value = 599; break;       /* scvtf --> scvtf.  */
22885     case 599: return NULL;              /* scvtf --> NULL.  */
22886     case 600: value = 601; break;       /* fcvtzs --> fcvtzs.  */
22887     case 601: return NULL;              /* fcvtzs --> NULL.  */
22888     case 614: value = 615; break;       /* ucvtf --> ucvtf.  */
22889     case 615: return NULL;              /* ucvtf --> NULL.  */
22890     case 616: value = 617; break;       /* fcvtzu --> fcvtzu.  */
22891     case 617: return NULL;              /* fcvtzu --> NULL.  */
22892     default: return NULL;
22893     }
22894
22895   return aarch64_opcode_table + value;
22896 }
22897
22898 const aarch64_opcode *
22899 aarch64_find_alias_opcode (const aarch64_opcode *opcode)
22900 {
22901   /* Use the index as the key to locate the alias opcode.  */
22902   int key = opcode - aarch64_opcode_table;
22903   int value;
22904   switch (key)
22905     {
22906     case 2: value = 3; break;   /* sbc --> ngc.  */
22907     case 4: value = 5; break;   /* sbcs --> ngcs.  */
22908     case 7: value = 8; break;   /* adds --> cmn.  */
22909     case 10: value = 11; break; /* subs --> cmp.  */
22910     case 12: value = 13; break; /* add --> mov.  */
22911     case 14: value = 15; break; /* adds --> cmn.  */
22912     case 17: value = 18; break; /* subs --> cmp.  */
22913     case 22: value = 23; break; /* adds --> cmn.  */
22914     case 24: value = 25; break; /* sub --> neg.  */
22915     case 26: value = 27; break; /* subs --> cmp.  */
22916     case 152: value = 153; break;       /* umov --> mov.  */
22917     case 154: value = 155; break;       /* ins --> mov.  */
22918     case 156: value = 157; break;       /* ins --> mov.  */
22919     case 242: value = 243; break;       /* not --> mvn.  */
22920     case 317: value = 318; break;       /* orr --> mov.  */
22921     case 388: value = 389; break;       /* sshll --> sxtl.  */
22922     case 390: value = 391; break;       /* sshll2 --> sxtl2.  */
22923     case 412: value = 413; break;       /* ushll --> uxtl.  */
22924     case 414: value = 415; break;       /* ushll2 --> uxtl2.  */
22925     case 535: value = 536; break;       /* dup --> mov.  */
22926     case 618: value = 623; break;       /* sbfm --> sxtw.  */
22927     case 625: value = 627; break;       /* bfm --> bfc.  */
22928     case 629: value = 633; break;       /* ubfm --> uxth.  */
22929     case 663: value = 665; break;       /* csinc --> cset.  */
22930     case 666: value = 668; break;       /* csinv --> csetm.  */
22931     case 669: value = 670; break;       /* csneg --> cneg.  */
22932     case 688: value = 688; break;       /* rev --> rev.  */
22933     case 713: value = 714; break;       /* lslv --> lsl.  */
22934     case 715: value = 716; break;       /* lsrv --> lsr.  */
22935     case 717: value = 718; break;       /* asrv --> asr.  */
22936     case 719: value = 720; break;       /* rorv --> ror.  */
22937     case 722: value = 723; break;       /* subps --> cmpp.  */
22938     case 735: value = 736; break;       /* madd --> mul.  */
22939     case 737: value = 738; break;       /* msub --> mneg.  */
22940     case 739: value = 740; break;       /* smaddl --> smull.  */
22941     case 741: value = 742; break;       /* smsubl --> smnegl.  */
22942     case 744: value = 745; break;       /* umaddl --> umull.  */
22943     case 746: value = 747; break;       /* umsubl --> umnegl.  */
22944     case 757: value = 758; break;       /* extr --> ror.  */
22945     case 990: value = 991; break;       /* and --> bic.  */
22946     case 992: value = 993; break;       /* orr --> mov.  */
22947     case 995: value = 996; break;       /* ands --> tst.  */
22948     case 999: value = 1001; break;      /* orr --> uxtw.  */
22949     case 1002: value = 1003; break;     /* orn --> mvn.  */
22950     case 1006: value = 1007; break;     /* ands --> tst.  */
22951     case 1037: value = 1133; break;     /* ldaddb --> staddb.  */
22952     case 1038: value = 1134; break;     /* ldaddh --> staddh.  */
22953     case 1039: value = 1135; break;     /* ldadd --> stadd.  */
22954     case 1041: value = 1136; break;     /* ldaddlb --> staddlb.  */
22955     case 1044: value = 1137; break;     /* ldaddlh --> staddlh.  */
22956     case 1047: value = 1138; break;     /* ldaddl --> staddl.  */
22957     case 1049: value = 1139; break;     /* ldclrb --> stclrb.  */
22958     case 1050: value = 1140; break;     /* ldclrh --> stclrh.  */
22959     case 1051: value = 1141; break;     /* ldclr --> stclr.  */
22960     case 1053: value = 1142; break;     /* ldclrlb --> stclrlb.  */
22961     case 1056: value = 1143; break;     /* ldclrlh --> stclrlh.  */
22962     case 1059: value = 1144; break;     /* ldclrl --> stclrl.  */
22963     case 1061: value = 1145; break;     /* ldeorb --> steorb.  */
22964     case 1062: value = 1146; break;     /* ldeorh --> steorh.  */
22965     case 1063: value = 1147; break;     /* ldeor --> steor.  */
22966     case 1065: value = 1148; break;     /* ldeorlb --> steorlb.  */
22967     case 1068: value = 1149; break;     /* ldeorlh --> steorlh.  */
22968     case 1071: value = 1150; break;     /* ldeorl --> steorl.  */
22969     case 1073: value = 1151; break;     /* ldsetb --> stsetb.  */
22970     case 1074: value = 1152; break;     /* ldseth --> stseth.  */
22971     case 1075: value = 1153; break;     /* ldset --> stset.  */
22972     case 1077: value = 1154; break;     /* ldsetlb --> stsetlb.  */
22973     case 1080: value = 1155; break;     /* ldsetlh --> stsetlh.  */
22974     case 1083: value = 1156; break;     /* ldsetl --> stsetl.  */
22975     case 1085: value = 1157; break;     /* ldsmaxb --> stsmaxb.  */
22976     case 1086: value = 1158; break;     /* ldsmaxh --> stsmaxh.  */
22977     case 1087: value = 1159; break;     /* ldsmax --> stsmax.  */
22978     case 1089: value = 1160; break;     /* ldsmaxlb --> stsmaxlb.  */
22979     case 1092: value = 1161; break;     /* ldsmaxlh --> stsmaxlh.  */
22980     case 1095: value = 1162; break;     /* ldsmaxl --> stsmaxl.  */
22981     case 1097: value = 1163; break;     /* ldsminb --> stsminb.  */
22982     case 1098: value = 1164; break;     /* ldsminh --> stsminh.  */
22983     case 1099: value = 1165; break;     /* ldsmin --> stsmin.  */
22984     case 1101: value = 1166; break;     /* ldsminlb --> stsminlb.  */
22985     case 1104: value = 1167; break;     /* ldsminlh --> stsminlh.  */
22986     case 1107: value = 1168; break;     /* ldsminl --> stsminl.  */
22987     case 1109: value = 1169; break;     /* ldumaxb --> stumaxb.  */
22988     case 1110: value = 1170; break;     /* ldumaxh --> stumaxh.  */
22989     case 1111: value = 1171; break;     /* ldumax --> stumax.  */
22990     case 1113: value = 1172; break;     /* ldumaxlb --> stumaxlb.  */
22991     case 1116: value = 1173; break;     /* ldumaxlh --> stumaxlh.  */
22992     case 1119: value = 1174; break;     /* ldumaxl --> stumaxl.  */
22993     case 1121: value = 1175; break;     /* lduminb --> stuminb.  */
22994     case 1122: value = 1176; break;     /* lduminh --> stuminh.  */
22995     case 1123: value = 1177; break;     /* ldumin --> stumin.  */
22996     case 1125: value = 1178; break;     /* lduminlb --> stuminlb.  */
22997     case 1128: value = 1179; break;     /* lduminlh --> stuminlh.  */
22998     case 1131: value = 1180; break;     /* lduminl --> stuminl.  */
22999     case 1181: value = 1182; break;     /* movn --> mov.  */
23000     case 1183: value = 1184; break;     /* movz --> mov.  */
23001     case 1193: value = 1234; break;     /* hint --> autibsp.  */
23002     case 1210: value = 1212; break;     /* dsb --> pssbb.  */
23003     case 1216: value = 1223; break;     /* sys --> cpp.  */
23004     case 1282: value = 2032; break;     /* and --> bic.  */
23005     case 1284: value = 1265; break;     /* and --> mov.  */
23006     case 1285: value = 1269; break;     /* ands --> movs.  */
23007     case 1320: value = 2033; break;     /* cmpge --> cmple.  */
23008     case 1323: value = 2036; break;     /* cmpgt --> cmplt.  */
23009     case 1325: value = 2034; break;     /* cmphi --> cmplo.  */
23010     case 1328: value = 2035; break;     /* cmphs --> cmpls.  */
23011     case 1350: value = 1262; break;     /* cpy --> mov.  */
23012     case 1351: value = 1264; break;     /* cpy --> mov.  */
23013     case 1352: value = 2043; break;     /* cpy --> fmov.  */
23014     case 1364: value = 1257; break;     /* dup --> mov.  */
23015     case 1365: value = 1259; break;     /* dup --> mov.  */
23016     case 1366: value = 2042; break;     /* dup --> fmov.  */
23017     case 1367: value = 1260; break;     /* dupm --> mov.  */
23018     case 1369: value = 2037; break;     /* eor --> eon.  */
23019     case 1371: value = 1270; break;     /* eor --> not.  */
23020     case 1372: value = 1271; break;     /* eors --> nots.  */
23021     case 1377: value = 2038; break;     /* facge --> facle.  */
23022     case 1378: value = 2039; break;     /* facgt --> faclt.  */
23023     case 1391: value = 2040; break;     /* fcmge --> fcmle.  */
23024     case 1393: value = 2041; break;     /* fcmgt --> fcmlt.  */
23025     case 1399: value = 1254; break;     /* fcpy --> fmov.  */
23026     case 1422: value = 1253; break;     /* fdup --> fmov.  */
23027     case 1753: value = 1255; break;     /* orr --> mov.  */
23028     case 1754: value = 2044; break;     /* orr --> orn.  */
23029     case 1756: value = 1258; break;     /* orr --> mov.  */
23030     case 1757: value = 1268; break;     /* orrs --> movs.  */
23031     case 1819: value = 1263; break;     /* sel --> mov.  */
23032     case 1820: value = 1266; break;     /* sel --> mov.  */
23033     default: return NULL;
23034     }
23035
23036   return aarch64_opcode_table + value;
23037 }
23038
23039 const aarch64_opcode *
23040 aarch64_find_next_alias_opcode (const aarch64_opcode *opcode)
23041 {
23042   /* Use the index as the key to locate the next opcode.  */
23043   int key = opcode - aarch64_opcode_table;
23044   int value;
23045   switch (key)
23046     {
23047     case 3: value = 2; break;   /* ngc --> sbc.  */
23048     case 5: value = 4; break;   /* ngcs --> sbcs.  */
23049     case 8: value = 7; break;   /* cmn --> adds.  */
23050     case 11: value = 10; break; /* cmp --> subs.  */
23051     case 13: value = 12; break; /* mov --> add.  */
23052     case 15: value = 14; break; /* cmn --> adds.  */
23053     case 18: value = 17; break; /* cmp --> subs.  */
23054     case 23: value = 22; break; /* cmn --> adds.  */
23055     case 25: value = 24; break; /* neg --> sub.  */
23056     case 27: value = 28; break; /* cmp --> negs.  */
23057     case 28: value = 26; break; /* negs --> subs.  */
23058     case 153: value = 152; break;       /* mov --> umov.  */
23059     case 155: value = 154; break;       /* mov --> ins.  */
23060     case 157: value = 156; break;       /* mov --> ins.  */
23061     case 243: value = 242; break;       /* mvn --> not.  */
23062     case 318: value = 317; break;       /* mov --> orr.  */
23063     case 389: value = 388; break;       /* sxtl --> sshll.  */
23064     case 391: value = 390; break;       /* sxtl2 --> sshll2.  */
23065     case 413: value = 412; break;       /* uxtl --> ushll.  */
23066     case 415: value = 414; break;       /* uxtl2 --> ushll2.  */
23067     case 536: value = 535; break;       /* mov --> dup.  */
23068     case 623: value = 622; break;       /* sxtw --> sxth.  */
23069     case 622: value = 621; break;       /* sxth --> sxtb.  */
23070     case 621: value = 624; break;       /* sxtb --> asr.  */
23071     case 624: value = 620; break;       /* asr --> sbfx.  */
23072     case 620: value = 619; break;       /* sbfx --> sbfiz.  */
23073     case 619: value = 618; break;       /* sbfiz --> sbfm.  */
23074     case 627: value = 628; break;       /* bfc --> bfxil.  */
23075     case 628: value = 626; break;       /* bfxil --> bfi.  */
23076     case 626: value = 625; break;       /* bfi --> bfm.  */
23077     case 633: value = 632; break;       /* uxth --> uxtb.  */
23078     case 632: value = 635; break;       /* uxtb --> lsr.  */
23079     case 635: value = 634; break;       /* lsr --> lsl.  */
23080     case 634: value = 631; break;       /* lsl --> ubfx.  */
23081     case 631: value = 630; break;       /* ubfx --> ubfiz.  */
23082     case 630: value = 629; break;       /* ubfiz --> ubfm.  */
23083     case 665: value = 664; break;       /* cset --> cinc.  */
23084     case 664: value = 663; break;       /* cinc --> csinc.  */
23085     case 668: value = 667; break;       /* csetm --> cinv.  */
23086     case 667: value = 666; break;       /* cinv --> csinv.  */
23087     case 670: value = 669; break;       /* cneg --> csneg.  */
23088     case 688: value = 689; break;       /* rev --> rev64.  */
23089     case 714: value = 713; break;       /* lsl --> lslv.  */
23090     case 716: value = 715; break;       /* lsr --> lsrv.  */
23091     case 718: value = 717; break;       /* asr --> asrv.  */
23092     case 720: value = 719; break;       /* ror --> rorv.  */
23093     case 723: value = 722; break;       /* cmpp --> subps.  */
23094     case 736: value = 735; break;       /* mul --> madd.  */
23095     case 738: value = 737; break;       /* mneg --> msub.  */
23096     case 740: value = 739; break;       /* smull --> smaddl.  */
23097     case 742: value = 741; break;       /* smnegl --> smsubl.  */
23098     case 745: value = 744; break;       /* umull --> umaddl.  */
23099     case 747: value = 746; break;       /* umnegl --> umsubl.  */
23100     case 758: value = 757; break;       /* ror --> extr.  */
23101     case 991: value = 990; break;       /* bic --> and.  */
23102     case 993: value = 992; break;       /* mov --> orr.  */
23103     case 996: value = 995; break;       /* tst --> ands.  */
23104     case 1001: value = 1000; break;     /* uxtw --> mov.  */
23105     case 1000: value = 999; break;      /* mov --> orr.  */
23106     case 1003: value = 1002; break;     /* mvn --> orn.  */
23107     case 1007: value = 1006; break;     /* tst --> ands.  */
23108     case 1133: value = 1037; break;     /* staddb --> ldaddb.  */
23109     case 1134: value = 1038; break;     /* staddh --> ldaddh.  */
23110     case 1135: value = 1039; break;     /* stadd --> ldadd.  */
23111     case 1136: value = 1041; break;     /* staddlb --> ldaddlb.  */
23112     case 1137: value = 1044; break;     /* staddlh --> ldaddlh.  */
23113     case 1138: value = 1047; break;     /* staddl --> ldaddl.  */
23114     case 1139: value = 1049; break;     /* stclrb --> ldclrb.  */
23115     case 1140: value = 1050; break;     /* stclrh --> ldclrh.  */
23116     case 1141: value = 1051; break;     /* stclr --> ldclr.  */
23117     case 1142: value = 1053; break;     /* stclrlb --> ldclrlb.  */
23118     case 1143: value = 1056; break;     /* stclrlh --> ldclrlh.  */
23119     case 1144: value = 1059; break;     /* stclrl --> ldclrl.  */
23120     case 1145: value = 1061; break;     /* steorb --> ldeorb.  */
23121     case 1146: value = 1062; break;     /* steorh --> ldeorh.  */
23122     case 1147: value = 1063; break;     /* steor --> ldeor.  */
23123     case 1148: value = 1065; break;     /* steorlb --> ldeorlb.  */
23124     case 1149: value = 1068; break;     /* steorlh --> ldeorlh.  */
23125     case 1150: value = 1071; break;     /* steorl --> ldeorl.  */
23126     case 1151: value = 1073; break;     /* stsetb --> ldsetb.  */
23127     case 1152: value = 1074; break;     /* stseth --> ldseth.  */
23128     case 1153: value = 1075; break;     /* stset --> ldset.  */
23129     case 1154: value = 1077; break;     /* stsetlb --> ldsetlb.  */
23130     case 1155: value = 1080; break;     /* stsetlh --> ldsetlh.  */
23131     case 1156: value = 1083; break;     /* stsetl --> ldsetl.  */
23132     case 1157: value = 1085; break;     /* stsmaxb --> ldsmaxb.  */
23133     case 1158: value = 1086; break;     /* stsmaxh --> ldsmaxh.  */
23134     case 1159: value = 1087; break;     /* stsmax --> ldsmax.  */
23135     case 1160: value = 1089; break;     /* stsmaxlb --> ldsmaxlb.  */
23136     case 1161: value = 1092; break;     /* stsmaxlh --> ldsmaxlh.  */
23137     case 1162: value = 1095; break;     /* stsmaxl --> ldsmaxl.  */
23138     case 1163: value = 1097; break;     /* stsminb --> ldsminb.  */
23139     case 1164: value = 1098; break;     /* stsminh --> ldsminh.  */
23140     case 1165: value = 1099; break;     /* stsmin --> ldsmin.  */
23141     case 1166: value = 1101; break;     /* stsminlb --> ldsminlb.  */
23142     case 1167: value = 1104; break;     /* stsminlh --> ldsminlh.  */
23143     case 1168: value = 1107; break;     /* stsminl --> ldsminl.  */
23144     case 1169: value = 1109; break;     /* stumaxb --> ldumaxb.  */
23145     case 1170: value = 1110; break;     /* stumaxh --> ldumaxh.  */
23146     case 1171: value = 1111; break;     /* stumax --> ldumax.  */
23147     case 1172: value = 1113; break;     /* stumaxlb --> ldumaxlb.  */
23148     case 1173: value = 1116; break;     /* stumaxlh --> ldumaxlh.  */
23149     case 1174: value = 1119; break;     /* stumaxl --> ldumaxl.  */
23150     case 1175: value = 1121; break;     /* stuminb --> lduminb.  */
23151     case 1176: value = 1122; break;     /* stuminh --> lduminh.  */
23152     case 1177: value = 1123; break;     /* stumin --> ldumin.  */
23153     case 1178: value = 1125; break;     /* stuminlb --> lduminlb.  */
23154     case 1179: value = 1128; break;     /* stuminlh --> lduminlh.  */
23155     case 1180: value = 1131; break;     /* stuminl --> lduminl.  */
23156     case 1182: value = 1181; break;     /* mov --> movn.  */
23157     case 1184: value = 1183; break;     /* mov --> movz.  */
23158     case 1234: value = 1233; break;     /* autibsp --> autibz.  */
23159     case 1233: value = 1232; break;     /* autibz --> autiasp.  */
23160     case 1232: value = 1231; break;     /* autiasp --> autiaz.  */
23161     case 1231: value = 1230; break;     /* autiaz --> pacibsp.  */
23162     case 1230: value = 1229; break;     /* pacibsp --> pacibz.  */
23163     case 1229: value = 1228; break;     /* pacibz --> paciasp.  */
23164     case 1228: value = 1227; break;     /* paciasp --> paciaz.  */
23165     case 1227: value = 1208; break;     /* paciaz --> psb.  */
23166     case 1208: value = 1207; break;     /* psb --> esb.  */
23167     case 1207: value = 1206; break;     /* esb --> autib1716.  */
23168     case 1206: value = 1205; break;     /* autib1716 --> autia1716.  */
23169     case 1205: value = 1204; break;     /* autia1716 --> pacib1716.  */
23170     case 1204: value = 1203; break;     /* pacib1716 --> pacia1716.  */
23171     case 1203: value = 1202; break;     /* pacia1716 --> xpaclri.  */
23172     case 1202: value = 1201; break;     /* xpaclri --> sevl.  */
23173     case 1201: value = 1200; break;     /* sevl --> sev.  */
23174     case 1200: value = 1199; break;     /* sev --> wfi.  */
23175     case 1199: value = 1198; break;     /* wfi --> wfe.  */
23176     case 1198: value = 1197; break;     /* wfe --> yield.  */
23177     case 1197: value = 1196; break;     /* yield --> bti.  */
23178     case 1196: value = 1195; break;     /* bti --> csdb.  */
23179     case 1195: value = 1194; break;     /* csdb --> nop.  */
23180     case 1194: value = 1193; break;     /* nop --> hint.  */
23181     case 1212: value = 1211; break;     /* pssbb --> ssbb.  */
23182     case 1211: value = 1210; break;     /* ssbb --> dsb.  */
23183     case 1223: value = 1222; break;     /* cpp --> dvp.  */
23184     case 1222: value = 1221; break;     /* dvp --> cfp.  */
23185     case 1221: value = 1220; break;     /* cfp --> tlbi.  */
23186     case 1220: value = 1219; break;     /* tlbi --> ic.  */
23187     case 1219: value = 1218; break;     /* ic --> dc.  */
23188     case 1218: value = 1217; break;     /* dc --> at.  */
23189     case 1217: value = 1216; break;     /* at --> sys.  */
23190     case 2032: value = 1282; break;     /* bic --> and.  */
23191     case 1265: value = 1284; break;     /* mov --> and.  */
23192     case 1269: value = 1285; break;     /* movs --> ands.  */
23193     case 2033: value = 1320; break;     /* cmple --> cmpge.  */
23194     case 2036: value = 1323; break;     /* cmplt --> cmpgt.  */
23195     case 2034: value = 1325; break;     /* cmplo --> cmphi.  */
23196     case 2035: value = 1328; break;     /* cmpls --> cmphs.  */
23197     case 1262: value = 1350; break;     /* mov --> cpy.  */
23198     case 1264: value = 1351; break;     /* mov --> cpy.  */
23199     case 2043: value = 1267; break;     /* fmov --> mov.  */
23200     case 1267: value = 1352; break;     /* mov --> cpy.  */
23201     case 1257: value = 1364; break;     /* mov --> dup.  */
23202     case 1259: value = 1256; break;     /* mov --> mov.  */
23203     case 1256: value = 1365; break;     /* mov --> dup.  */
23204     case 2042: value = 1261; break;     /* fmov --> mov.  */
23205     case 1261: value = 1366; break;     /* mov --> dup.  */
23206     case 1260: value = 1367; break;     /* mov --> dupm.  */
23207     case 2037: value = 1369; break;     /* eon --> eor.  */
23208     case 1270: value = 1371; break;     /* not --> eor.  */
23209     case 1271: value = 1372; break;     /* nots --> eors.  */
23210     case 2038: value = 1377; break;     /* facle --> facge.  */
23211     case 2039: value = 1378; break;     /* faclt --> facgt.  */
23212     case 2040: value = 1391; break;     /* fcmle --> fcmge.  */
23213     case 2041: value = 1393; break;     /* fcmlt --> fcmgt.  */
23214     case 1254: value = 1399; break;     /* fmov --> fcpy.  */
23215     case 1253: value = 1422; break;     /* fmov --> fdup.  */
23216     case 1255: value = 1753; break;     /* mov --> orr.  */
23217     case 2044: value = 1754; break;     /* orn --> orr.  */
23218     case 1258: value = 1756; break;     /* mov --> orr.  */
23219     case 1268: value = 1757; break;     /* movs --> orrs.  */
23220     case 1263: value = 1819; break;     /* mov --> sel.  */
23221     case 1266: value = 1820; break;     /* mov --> sel.  */
23222     default: return NULL;
23223     }
23224
23225   return aarch64_opcode_table + value;
23226 }
23227
23228 bfd_boolean
23229 aarch64_extract_operand (const aarch64_operand *self,
23230                            aarch64_opnd_info *info,
23231                            aarch64_insn code, const aarch64_inst *inst,
23232                            aarch64_operand_error *errors)
23233 {
23234   /* Use the index as the key.  */
23235   int key = self - aarch64_operands;
23236   switch (key)
23237     {
23238     case 1:
23239     case 2:
23240     case 3:
23241     case 4:
23242     case 5:
23243     case 6:
23244     case 7:
23245     case 8:
23246     case 10:
23247     case 11:
23248     case 12:
23249     case 16:
23250     case 17:
23251     case 18:
23252     case 19:
23253     case 21:
23254     case 22:
23255     case 23:
23256     case 24:
23257     case 25:
23258     case 26:
23259     case 27:
23260     case 28:
23261     case 29:
23262     case 30:
23263     case 162:
23264     case 163:
23265     case 164:
23266     case 165:
23267     case 166:
23268     case 167:
23269     case 168:
23270     case 169:
23271     case 170:
23272     case 171:
23273     case 186:
23274     case 187:
23275     case 188:
23276     case 189:
23277     case 190:
23278     case 191:
23279     case 192:
23280     case 193:
23281     case 194:
23282     case 200:
23283     case 203:
23284       return aarch64_ext_regno (self, info, code, inst, errors);
23285     case 9:
23286       return aarch64_ext_regrt_sysins (self, info, code, inst, errors);
23287     case 13:
23288       return aarch64_ext_regno_pair (self, info, code, inst, errors);
23289     case 14:
23290       return aarch64_ext_reg_extended (self, info, code, inst, errors);
23291     case 15:
23292       return aarch64_ext_reg_shifted (self, info, code, inst, errors);
23293     case 20:
23294       return aarch64_ext_ft (self, info, code, inst, errors);
23295     case 31:
23296     case 32:
23297     case 33:
23298     case 34:
23299     case 206:
23300       return aarch64_ext_reglane (self, info, code, inst, errors);
23301     case 35:
23302       return aarch64_ext_reglist (self, info, code, inst, errors);
23303     case 36:
23304       return aarch64_ext_ldst_reglist (self, info, code, inst, errors);
23305     case 37:
23306       return aarch64_ext_ldst_reglist_r (self, info, code, inst, errors);
23307     case 38:
23308       return aarch64_ext_ldst_elemlist (self, info, code, inst, errors);
23309     case 39:
23310     case 40:
23311     case 41:
23312     case 42:
23313     case 52:
23314     case 53:
23315     case 54:
23316     case 55:
23317     case 56:
23318     case 57:
23319     case 58:
23320     case 59:
23321     case 60:
23322     case 61:
23323     case 62:
23324     case 63:
23325     case 64:
23326     case 65:
23327     case 66:
23328     case 67:
23329     case 78:
23330     case 79:
23331     case 80:
23332     case 81:
23333     case 82:
23334     case 159:
23335     case 161:
23336     case 178:
23337     case 179:
23338     case 180:
23339     case 181:
23340     case 182:
23341     case 183:
23342     case 184:
23343     case 185:
23344     case 205:
23345       return aarch64_ext_imm (self, info, code, inst, errors);
23346     case 43:
23347     case 44:
23348       return aarch64_ext_advsimd_imm_shift (self, info, code, inst, errors);
23349     case 45:
23350     case 46:
23351     case 47:
23352       return aarch64_ext_advsimd_imm_modified (self, info, code, inst, errors);
23353     case 48:
23354       return aarch64_ext_shll_imm (self, info, code, inst, errors);
23355     case 51:
23356     case 149:
23357       return aarch64_ext_fpimm (self, info, code, inst, errors);
23358     case 68:
23359     case 157:
23360       return aarch64_ext_limm (self, info, code, inst, errors);
23361     case 69:
23362       return aarch64_ext_aimm (self, info, code, inst, errors);
23363     case 70:
23364       return aarch64_ext_imm_half (self, info, code, inst, errors);
23365     case 71:
23366       return aarch64_ext_fbits (self, info, code, inst, errors);
23367     case 73:
23368     case 74:
23369     case 154:
23370       return aarch64_ext_imm_rotate2 (self, info, code, inst, errors);
23371     case 75:
23372     case 153:
23373     case 155:
23374       return aarch64_ext_imm_rotate1 (self, info, code, inst, errors);
23375     case 76:
23376     case 77:
23377       return aarch64_ext_cond (self, info, code, inst, errors);
23378     case 83:
23379     case 92:
23380       return aarch64_ext_addr_simple (self, info, code, inst, errors);
23381     case 84:
23382       return aarch64_ext_addr_regoff (self, info, code, inst, errors);
23383     case 85:
23384     case 86:
23385     case 87:
23386     case 89:
23387     case 91:
23388       return aarch64_ext_addr_simm (self, info, code, inst, errors);
23389     case 88:
23390       return aarch64_ext_addr_simm10 (self, info, code, inst, errors);
23391     case 90:
23392       return aarch64_ext_addr_uimm12 (self, info, code, inst, errors);
23393     case 93:
23394       return aarch64_ext_addr_offset (self, info, code, inst, errors);
23395     case 94:
23396       return aarch64_ext_simd_addr_post (self, info, code, inst, errors);
23397     case 95:
23398       return aarch64_ext_sysreg (self, info, code, inst, errors);
23399     case 96:
23400       return aarch64_ext_pstatefield (self, info, code, inst, errors);
23401     case 97:
23402     case 98:
23403     case 99:
23404     case 100:
23405     case 101:
23406       return aarch64_ext_sysins_op (self, info, code, inst, errors);
23407     case 102:
23408     case 103:
23409       return aarch64_ext_barrier (self, info, code, inst, errors);
23410     case 104:
23411       return aarch64_ext_prfop (self, info, code, inst, errors);
23412     case 105:
23413     case 106:
23414       return aarch64_ext_hint (self, info, code, inst, errors);
23415     case 107:
23416       return aarch64_ext_sve_addr_ri_s4 (self, info, code, inst, errors);
23417     case 108:
23418     case 109:
23419     case 110:
23420     case 111:
23421       return aarch64_ext_sve_addr_ri_s4xvl (self, info, code, inst, errors);
23422     case 112:
23423       return aarch64_ext_sve_addr_ri_s6xvl (self, info, code, inst, errors);
23424     case 113:
23425       return aarch64_ext_sve_addr_ri_s9xvl (self, info, code, inst, errors);
23426     case 114:
23427     case 115:
23428     case 116:
23429     case 117:
23430       return aarch64_ext_sve_addr_ri_u6 (self, info, code, inst, errors);
23431     case 118:
23432     case 119:
23433     case 120:
23434     case 121:
23435     case 122:
23436     case 123:
23437     case 124:
23438     case 125:
23439     case 126:
23440     case 127:
23441     case 128:
23442     case 129:
23443     case 130:
23444     case 131:
23445       return aarch64_ext_sve_addr_rr_lsl (self, info, code, inst, errors);
23446     case 132:
23447     case 133:
23448     case 134:
23449     case 135:
23450     case 136:
23451     case 137:
23452     case 138:
23453     case 139:
23454       return aarch64_ext_sve_addr_rz_xtw (self, info, code, inst, errors);
23455     case 140:
23456     case 141:
23457     case 142:
23458     case 143:
23459       return aarch64_ext_sve_addr_zi_u5 (self, info, code, inst, errors);
23460     case 144:
23461       return aarch64_ext_sve_addr_zz_lsl (self, info, code, inst, errors);
23462     case 145:
23463       return aarch64_ext_sve_addr_zz_sxtw (self, info, code, inst, errors);
23464     case 146:
23465       return aarch64_ext_sve_addr_zz_uxtw (self, info, code, inst, errors);
23466     case 147:
23467       return aarch64_ext_sve_aimm (self, info, code, inst, errors);
23468     case 148:
23469       return aarch64_ext_sve_asimm (self, info, code, inst, errors);
23470     case 150:
23471       return aarch64_ext_sve_float_half_one (self, info, code, inst, errors);
23472     case 151:
23473       return aarch64_ext_sve_float_half_two (self, info, code, inst, errors);
23474     case 152:
23475       return aarch64_ext_sve_float_zero_one (self, info, code, inst, errors);
23476     case 156:
23477       return aarch64_ext_inv_limm (self, info, code, inst, errors);
23478     case 158:
23479       return aarch64_ext_sve_limm_mov (self, info, code, inst, errors);
23480     case 160:
23481       return aarch64_ext_sve_scale (self, info, code, inst, errors);
23482     case 172:
23483     case 173:
23484     case 174:
23485       return aarch64_ext_sve_shlimm (self, info, code, inst, errors);
23486     case 175:
23487     case 176:
23488     case 177:
23489       return aarch64_ext_sve_shrimm (self, info, code, inst, errors);
23490     case 195:
23491     case 196:
23492     case 197:
23493     case 198:
23494     case 199:
23495       return aarch64_ext_sve_quad_index (self, info, code, inst, errors);
23496     case 201:
23497       return aarch64_ext_sve_index (self, info, code, inst, errors);
23498     case 202:
23499     case 204:
23500       return aarch64_ext_sve_reglist (self, info, code, inst, errors);
23501     default: assert (0); abort ();
23502     }
23503 }