opcodes/aarch64-dis-2.c

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