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