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 >> 29) & 0x1) == 0)
3133             {
3134               if (((word >> 30) & 0x1) == 0)
3135                 {
3136                   if (((word >> 31) & 0x1) == 0)
3137                     {
3138                       /* 33222222222211111111110000000000
3139                          10987654321098765432109876543210
3140                          xxxxxxxxxxxxxxxxxxxxxxxxxx10x000
3141                          b.  */
3142                       return 627;
3143                     }
3144                   else
3145                     {
3146                       /* 33222222222211111111110000000000
3147                          10987654321098765432109876543210
3148                          xxxxxxxxxxxxxxxxxxxxxxxxxx10x001
3149                          bl.  */
3150                       return 628;
3151                     }
3152                 }
3153               else
3154                 {
3155                   if (((word >> 24) & 0x1) == 0)
3156                     {
3157                       if (((word >> 25) & 0x1) == 0)
3158                         {
3159                           if (((word >> 31) & 0x1) == 0)
3160                             {
3161                               /* 33222222222211111111110000000000
3162                                  10987654321098765432109876543210
3163                                  xxxxxxxxxxxxxxxxxxxxxxxx0010x010
3164                                  b.c.  */
3165                               return 636;
3166                             }
3167                           else
3168                             {
3169                               if (((word >> 0) & 0x1) == 0)
3170                                 {
3171                                   if (((word >> 1) & 0x1) == 0)
3172                                     {
3173                                       if (((word >> 21) & 0x1) == 0)
3174                                         {
3175                                           /* 33222222222211111111110000000000
3176                                              10987654321098765432109876543210
3177                                              00xxxxxxxxxxxxxxxxxxx0xx0010x011
3178                                              hlt.  */
3179                                           return 708;
3180                                         }
3181                                       else
3182                                         {
3183                                           /* 33222222222211111111110000000000
3184                                              10987654321098765432109876543210
3185                                              00xxxxxxxxxxxxxxxxxxx1xx0010x011
3186                                              brk.  */
3187                                           return 707;
3188                                         }
3189                                     }
3190                                   else
3191                                     {
3192                                       if (((word >> 21) & 0x1) == 0)
3193                                         {
3194                                           /* 33222222222211111111110000000000
3195                                              10987654321098765432109876543210
3196                                              01xxxxxxxxxxxxxxxxxxx0xx0010x011
3197                                              hvc.  */
3198                                           return 705;
3199                                         }
3200                                       else
3201                                         {
3202                                           /* 33222222222211111111110000000000
3203                                              10987654321098765432109876543210
3204                                              01xxxxxxxxxxxxxxxxxxx1xx0010x011
3205                                              dcps2.  */
3206                                           return 710;
3207                                         }
3208                                     }
3209                                 }
3210                               else
3211                                 {
3212                                   if (((word >> 1) & 0x1) == 0)
3213                                     {
3214                                       if (((word >> 21) & 0x1) == 0)
3215                                         {
3216                                           /* 33222222222211111111110000000000
3217                                              10987654321098765432109876543210
3218                                              10xxxxxxxxxxxxxxxxxxx0xx0010x011
3219                                              svc.  */
3220                                           return 704;
3221                                         }
3222                                       else
3223                                         {
3224                                           /* 33222222222211111111110000000000
3225                                              10987654321098765432109876543210
3226                                              10xxxxxxxxxxxxxxxxxxx1xx0010x011
3227                                              dcps1.  */
3228                                           return 709;
3229                                         }
3230                                     }
3231                                   else
3232                                     {
3233                                       if (((word >> 21) & 0x1) == 0)
3234                                         {
3235                                           /* 33222222222211111111110000000000
3236                                              10987654321098765432109876543210
3237                                              11xxxxxxxxxxxxxxxxxxx0xx0010x011
3238                                              smc.  */
3239                                           return 706;
3240                                         }
3241                                       else
3242                                         {
3243                                           /* 33222222222211111111110000000000
3244                                              10987654321098765432109876543210
3245                                              11xxxxxxxxxxxxxxxxxxx1xx0010x011
3246                                              dcps3.  */
3247                                           return 711;
3248                                         }
3249                                     }
3250                                 }
3251                             }
3252                         }
3253                       else
3254                         {
3255                           if (((word >> 21) & 0x1) == 0)
3256                             {
3257                               if (((word >> 22) & 0x1) == 0)
3258                                 {
3259                                   if (((word >> 23) & 0x1) == 0)
3260                                     {
3261                                       /* 33222222222211111111110000000000
3262                                          10987654321098765432109876543210
3263                                          xxxxxxxxxxxxxxxxxxxxx0000110x01x
3264                                          br.  */
3265                                       return 629;
3266                                     }
3267                                   else
3268                                     {
3269                                       /* 33222222222211111111110000000000
3270                                          10987654321098765432109876543210
3271                                          xxxxxxxxxxxxxxxxxxxxx0010110x01x
3272                                          eret.  */
3273                                       return 632;
3274                                     }
3275                                 }
3276                               else
3277                                 {
3278                                   /* 33222222222211111111110000000000
3279                                      10987654321098765432109876543210
3280                                      xxxxxxxxxxxxxxxxxxxxx01x0110x01x
3281                                      ret.  */
3282                                   return 631;
3283                                 }
3284                             }
3285                           else
3286                             {
3287                               if (((word >> 23) & 0x1) == 0)
3288                                 {
3289                                   /* 33222222222211111111110000000000
3290                                      10987654321098765432109876543210
3291                                      xxxxxxxxxxxxxxxxxxxxx1x00110x01x
3292                                      blr.  */
3293                                   return 630;
3294                                 }
3295                               else
3296                                 {
3297                                   /* 33222222222211111111110000000000
3298                                      10987654321098765432109876543210
3299                                      xxxxxxxxxxxxxxxxxxxxx1x10110x01x
3300                                      drps.  */
3301                                   return 633;
3302                                 }
3303                             }
3304                         }
3305                     }
3306                   else
3307                     {
3308                       if (((word >> 21) & 0x1) == 0)
3309                         {
3310                           /* 33222222222211111111110000000000
3311                              10987654321098765432109876543210
3312                              xxxxxxxxxxxxxxxxxxxxx0xx1x10x01x
3313                              msr.  */
3314                           return 1117;
3315                         }
3316                       else
3317                         {
3318                           /* 33222222222211111111110000000000
3319                              10987654321098765432109876543210
3320                              xxxxxxxxxxxxxxxxxxxxx1xx1x10x01x
3321                              sysl.  */
3322                           return 1137;
3323                         }
3324                     }
3325                 }
3326             }
3327           else
3328             {
3329               if (((word >> 24) & 0x1) == 0)
3330                 {
3331                   if (((word >> 25) & 0x1) == 0)
3332                     {
3333                       /* 33222222222211111111110000000000
3334                          10987654321098765432109876543210
3335                          xxxxxxxxxxxxxxxxxxxxxxxx0010x1xx
3336                          cbz.  */
3337                       return 634;
3338                     }
3339                   else
3340                     {
3341                       /* 33222222222211111111110000000000
3342                          10987654321098765432109876543210
3343                          xxxxxxxxxxxxxxxxxxxxxxxx0110x1xx
3344                          tbz.  */
3345                       return 1139;
3346                     }
3347                 }
3348               else
3349                 {
3350                   if (((word >> 25) & 0x1) == 0)
3351                     {
3352                       /* 33222222222211111111110000000000
3353                          10987654321098765432109876543210
3354                          xxxxxxxxxxxxxxxxxxxxxxxx1010x1xx
3355                          cbnz.  */
3356                       return 635;
3357                     }
3358                   else
3359                     {
3360                       /* 33222222222211111111110000000000
3361                          10987654321098765432109876543210
3362                          xxxxxxxxxxxxxxxxxxxxxxxx1110x1xx
3363                          tbnz.  */
3364                       return 1140;
3365                     }
3366                 }
3367             }
3368         }
3369       else
3370         {
3371           if (((word >> 25) & 0x1) == 0)
3372             {
3373               if (((word >> 28) & 0x1) == 0)
3374                 {
3375                   if (((word >> 22) & 0x1) == 0)
3376                     {
3377                       if (((word >> 23) & 0x1) == 0)
3378                         {
3379                           if (((word >> 24) & 0x1) == 0)
3380                             {
3381                               if (((word >> 29) & 0x1) == 0)
3382                                 {
3383                                   /* 33222222222211111111110000000000
3384                                      10987654321098765432109876543210
3385                                      xxxxxxxxxxxxxxxxxxxxxx00001100xx
3386                                      st4.  */
3387                                   return 431;
3388                                 }
3389                               else
3390                                 {
3391                                   /* 33222222222211111111110000000000
3392                                      10987654321098765432109876543210
3393                                      xxxxxxxxxxxxxxxxxxxxxx00001101xx
3394                                      stnp.  */
3395                                   return 903;
3396                                 }
3397                             }
3398                           else
3399                             {
3400                               if (((word >> 29) & 0x1) == 0)
3401                                 {
3402                                   if (((word >> 13) & 0x1) == 0)
3403                                     {
3404                                       if (((word >> 21) & 0x1) == 0)
3405                                         {
3406                                           /* 33222222222211111111110000000000
3407                                              10987654321098765432109876543210
3408                                              xxxxxxxxxxxxx0xxxxxxx000101100xx
3409                                              st1.  */
3410                                           return 447;
3411                                         }
3412                                       else
3413                                         {
3414                                           /* 33222222222211111111110000000000
3415                                              10987654321098765432109876543210
3416                                              xxxxxxxxxxxxx0xxxxxxx100101100xx
3417                                              st2.  */
3418                                           return 449;
3419                                         }
3420                                     }
3421                                   else
3422                                     {
3423                                       if (((word >> 21) & 0x1) == 0)
3424                                         {
3425                                           /* 33222222222211111111110000000000
3426                                              10987654321098765432109876543210
3427                                              xxxxxxxxxxxxx1xxxxxxx000101100xx
3428                                              st3.  */
3429                                           return 448;
3430                                         }
3431                                       else
3432                                         {
3433                                           /* 33222222222211111111110000000000
3434                                              10987654321098765432109876543210
3435                                              xxxxxxxxxxxxx1xxxxxxx100101100xx
3436                                              st4.  */
3437                                           return 450;
3438                                         }
3439                                     }
3440                                 }
3441                               else
3442                                 {
3443                                   /* 33222222222211111111110000000000
3444                                      10987654321098765432109876543210
3445                                      xxxxxxxxxxxxxxxxxxxxxx00101101xx
3446                                      stp.  */
3447                                   return 907;
3448                                 }
3449                             }
3450                         }
3451                       else
3452                         {
3453                           if (((word >> 29) & 0x1) == 0)
3454                             {
3455                               if (((word >> 21) & 0x1) == 0)
3456                                 {
3457                                   if (((word >> 24) & 0x1) == 0)
3458                                     {
3459                                       /* 33222222222211111111110000000000
3460                                          10987654321098765432109876543210
3461                                          xxxxxxxxxxxxxxxxxxxxx001001100xx
3462                                          st4.  */
3463                                       return 439;
3464                                     }
3465                                   else
3466                                     {
3467                                       if (((word >> 13) & 0x1) == 0)
3468                                         {
3469                                           /* 33222222222211111111110000000000
3470                                              10987654321098765432109876543210
3471                                              xxxxxxxxxxxxx0xxxxxxx001101100xx
3472                                              st1.  */
3473                                           return 459;
3474                                         }
3475                                       else
3476                                         {
3477                                           /* 33222222222211111111110000000000
3478                                              10987654321098765432109876543210
3479                                              xxxxxxxxxxxxx1xxxxxxx001101100xx
3480                                              st3.  */
3481                                           return 460;
3482                                         }
3483                                     }
3484                                 }
3485                               else
3486                                 {
3487                                   if (((word >> 13) & 0x1) == 0)
3488                                     {
3489                                       /* 33222222222211111111110000000000
3490                                          10987654321098765432109876543210
3491                                          xxxxxxxxxxxxx0xxxxxxx101x01100xx
3492                                          st2.  */
3493                                       return 461;
3494                                     }
3495                                   else
3496                                     {
3497                                       /* 33222222222211111111110000000000
3498                                          10987654321098765432109876543210
3499                                          xxxxxxxxxxxxx1xxxxxxx101x01100xx
3500                                          st4.  */
3501                                       return 462;
3502                                     }
3503                                 }
3504                             }
3505                           else
3506                             {
3507                               /* 33222222222211111111110000000000
3508                                  10987654321098765432109876543210
3509                                  xxxxxxxxxxxxxxxxxxxxxx01x01101xx
3510                                  stp.  */
3511                               return 912;
3512                             }
3513                         }
3514                     }
3515                   else
3516                     {
3517                       if (((word >> 23) & 0x1) == 0)
3518                         {
3519                           if (((word >> 24) & 0x1) == 0)
3520                             {
3521                               if (((word >> 29) & 0x1) == 0)
3522                                 {
3523                                   /* 33222222222211111111110000000000
3524                                      10987654321098765432109876543210
3525                                      xxxxxxxxxxxxxxxxxxxxxx10001100xx
3526                                      ld4.  */
3527                                   return 435;
3528                                 }
3529                               else
3530                                 {
3531                                   /* 33222222222211111111110000000000
3532                                      10987654321098765432109876543210
3533                                      xxxxxxxxxxxxxxxxxxxxxx10001101xx
3534                                      ldnp.  */
3535                                   return 904;
3536                                 }
3537                             }
3538                           else
3539                             {
3540                               if (((word >> 29) & 0x1) == 0)
3541                                 {
3542                                   if (((word >> 13) & 0x1) == 0)
3543                                     {
3544                                       if (((word >> 21) & 0x1) == 0)
3545                                         {
3546                                           /* 33222222222211111111110000000000
3547                                              10987654321098765432109876543210
3548                                              xxxxxxxxxxxxx0xxxxxxx010101100xx
3549                                              ld1.  */
3550                                           return 451;
3551                                         }
3552                                       else
3553                                         {
3554                                           /* 33222222222211111111110000000000
3555                                              10987654321098765432109876543210
3556                                              xxxxxxxxxxxxx0xxxxxxx110101100xx
3557                                              ld2.  */
3558                                           return 455;
3559                                         }
3560                                     }
3561                                   else
3562                                     {
3563                                       if (((word >> 21) & 0x1) == 0)
3564                                         {
3565                                           /* 33222222222211111111110000000000
3566                                              10987654321098765432109876543210
3567                                              xxxxxxxxxxxxx1xxxxxxx010101100xx
3568                                              ld3.  */
3569                                           return 452;
3570                                         }
3571                                       else
3572                                         {
3573                                           /* 33222222222211111111110000000000
3574                                              10987654321098765432109876543210
3575                                              xxxxxxxxxxxxx1xxxxxxx110101100xx
3576                                              ld4.  */
3577                                           return 456;
3578                                         }
3579                                     }
3580                                 }
3581                               else
3582                                 {
3583                                   /* 33222222222211111111110000000000
3584                                      10987654321098765432109876543210
3585                                      xxxxxxxxxxxxxxxxxxxxxx10101101xx
3586                                      ldp.  */
3587                                   return 908;
3588                                 }
3589                             }
3590                         }
3591                       else
3592                         {
3593                           if (((word >> 29) & 0x1) == 0)
3594                             {
3595                               if (((word >> 21) & 0x1) == 0)
3596                                 {
3597                                   if (((word >> 24) & 0x1) == 0)
3598                                     {
3599                                       /* 33222222222211111111110000000000
3600                                          10987654321098765432109876543210
3601                                          xxxxxxxxxxxxxxxxxxxxx011001100xx
3602                                          ld4.  */
3603                                       return 443;
3604                                     }
3605                                   else
3606                                     {
3607                                       if (((word >> 13) & 0x1) == 0)
3608                                         {
3609                                           /* 33222222222211111111110000000000
3610                                              10987654321098765432109876543210
3611                                              xxxxxxxxxxxxx0xxxxxxx011101100xx
3612                                              ld1.  */
3613                                           return 463;
3614                                         }
3615                                       else
3616                                         {
3617                                           /* 33222222222211111111110000000000
3618                                              10987654321098765432109876543210
3619                                              xxxxxxxxxxxxx1xxxxxxx011101100xx
3620                                              ld3.  */
3621                                           return 464;
3622                                         }
3623                                     }
3624                                 }
3625                               else
3626                                 {
3627                                   if (((word >> 13) & 0x1) == 0)
3628                                     {
3629                                       /* 33222222222211111111110000000000
3630                                          10987654321098765432109876543210
3631                                          xxxxxxxxxxxxx0xxxxxxx111x01100xx
3632                                          ld2.  */
3633                                       return 467;
3634                                     }
3635                                   else
3636                                     {
3637                                       /* 33222222222211111111110000000000
3638                                          10987654321098765432109876543210
3639                                          xxxxxxxxxxxxx1xxxxxxx111x01100xx
3640                                          ld4.  */
3641                                       return 468;
3642                                     }
3643                                 }
3644                             }
3645                           else
3646                             {
3647                               /* 33222222222211111111110000000000
3648                                  10987654321098765432109876543210
3649                                  xxxxxxxxxxxxxxxxxxxxxx11x01101xx
3650                                  ldp.  */
3651                               return 913;
3652                             }
3653                         }
3654                     }
3655                 }
3656               else
3657                 {
3658                   if (((word >> 24) & 0x1) == 0)
3659                     {
3660                       if (((word >> 29) & 0x1) == 0)
3661                         {
3662                           /* 33222222222211111111110000000000
3663                              10987654321098765432109876543210
3664                              xxxxxxxxxxxxxxxxxxxxxxxx001110xx
3665                              ldr.  */
3666                           return 916;
3667                         }
3668                       else
3669                         {
3670                           if (((word >> 10) & 0x1) == 0)
3671                             {
3672                               if (((word >> 11) & 0x1) == 0)
3673                                 {
3674                                   if (((word >> 22) & 0x1) == 0)
3675                                     {
3676                                       /* 33222222222211111111110000000000
3677                                          10987654321098765432109876543210
3678                                          xxxxxxxxxx00xxxxxxxxxx0x001111xx
3679                                          stur.  */
3680                                       return 864;
3681                                     }
3682                                   else
3683                                     {
3684                                       /* 33222222222211111111110000000000
3685                                          10987654321098765432109876543210
3686                                          xxxxxxxxxx00xxxxxxxxxx1x001111xx
3687                                          ldur.  */
3688                                       return 865;
3689                                     }
3690                                 }
3691                               else
3692                                 {
3693                                   if (((word >> 22) & 0x1) == 0)
3694                                     {
3695                                       /* 33222222222211111111110000000000
3696                                          10987654321098765432109876543210
3697                                          xxxxxxxxxx01xxxxxxxxxx0x001111xx
3698                                          str.  */
3699                                       return 843;
3700                                     }
3701                                   else
3702                                     {
3703                                       /* 33222222222211111111110000000000
3704                                          10987654321098765432109876543210
3705                                          xxxxxxxxxx01xxxxxxxxxx1x001111xx
3706                                          ldr.  */
3707                                       return 844;
3708                                     }
3709                                 }
3710                             }
3711                           else
3712                             {
3713                               if (((word >> 22) & 0x1) == 0)
3714                                 {
3715                                   /* 33222222222211111111110000000000
3716                                      10987654321098765432109876543210
3717                                      xxxxxxxxxx1xxxxxxxxxxx0x001111xx
3718                                      str.  */
3719                                   return 820;
3720                                 }
3721                               else
3722                                 {
3723                                   /* 33222222222211111111110000000000
3724                                      10987654321098765432109876543210
3725                                      xxxxxxxxxx1xxxxxxxxxxx1x001111xx
3726                                      ldr.  */
3727                                   return 821;
3728                                 }
3729                             }
3730                         }
3731                     }
3732                   else
3733                     {
3734                       if (((word >> 22) & 0x1) == 0)
3735                         {
3736                           /* 33222222222211111111110000000000
3737                              10987654321098765432109876543210
3738                              xxxxxxxxxxxxxxxxxxxxxx0x10111xxx
3739                              str.  */
3740                           return 831;
3741                         }
3742                       else
3743                         {
3744                           /* 33222222222211111111110000000000
3745                              10987654321098765432109876543210
3746                              xxxxxxxxxxxxxxxxxxxxxx1x10111xxx
3747                              ldr.  */
3748                           return 832;
3749                         }
3750                     }
3751                 }
3752             }
3753           else
3754             {
3755               if (((word >> 24) & 0x1) == 0)
3756                 {
3757                   if (((word >> 21) & 0x1) == 0)
3758                     {
3759                       if (((word >> 28) & 0x1) == 0)
3760                         {
3761                           if (((word >> 10) & 0x1) == 0)
3762                             {
3763                               if (((word >> 29) & 0x1) == 0)
3764                                 {
3765                                   if (((word >> 11) & 0x1) == 0)
3766                                     {
3767                                       if (((word >> 12) & 0x1) == 0)
3768                                         {
3769                                           /* 33222222222211111111110000000000
3770                                              10987654321098765432109876543210
3771                                              xxxxxxxxxx000xxxxxxxx0xx011100xx
3772                                              tbl.  */
3773                                           return 411;
3774                                         }
3775                                       else
3776                                         {
3777                                           /* 33222222222211111111110000000000
3778                                              10987654321098765432109876543210
3779                                              xxxxxxxxxx001xxxxxxxx0xx011100xx
3780                                              tbx.  */
3781                                           return 412;
3782                                         }
3783                                     }
3784                                   else
3785                                     {
3786                                       if (((word >> 12) & 0x1) == 0)
3787                                         {
3788                                           if (((word >> 14) & 0x1) == 0)
3789                                             {
3790                                               /* 33222222222211111111110000000000
3791                                                  10987654321098765432109876543210
3792                                                  xxxxxxxxxx010x0xxxxxx0xx011100xx
3793                                                  trn1.  */
3794                                               return 256;
3795                                             }
3796                                           else
3797                                             {
3798                                               /* 33222222222211111111110000000000
3799                                                  10987654321098765432109876543210
3800                                                  xxxxxxxxxx010x1xxxxxx0xx011100xx
3801                                                  trn2.  */
3802                                               return 259;
3803                                             }
3804                                         }
3805                                       else
3806                                         {
3807                                           if (((word >> 13) & 0x1) == 0)
3808                                             {
3809                                               if (((word >> 14) & 0x1) == 0)
3810                                                 {
3811                                                   /* 33222222222211111111110000000000
3812                                                      10987654321098765432109876543210
3813                                                      xxxxxxxxxx01100xxxxxx0xx011100xx
3814                                                      uzp1.  */
3815                                                   return 255;
3816                                                 }
3817                                               else
3818                                                 {
3819                                                   /* 33222222222211111111110000000000
3820                                                      10987654321098765432109876543210
3821                                                      xxxxxxxxxx01101xxxxxx0xx011100xx
3822                                                      uzp2.  */
3823                                                   return 258;
3824                                                 }
3825                                             }
3826                                           else
3827                                             {
3828                                               if (((word >> 14) & 0x1) == 0)
3829                                                 {
3830                                                   /* 33222222222211111111110000000000
3831                                                      10987654321098765432109876543210
3832                                                      xxxxxxxxxx01110xxxxxx0xx011100xx
3833                                                      zip1.  */
3834                                                   return 257;
3835                                                 }
3836                                               else
3837                                                 {
3838                                                   /* 33222222222211111111110000000000
3839                                                      10987654321098765432109876543210
3840                                                      xxxxxxxxxx01111xxxxxx0xx011100xx
3841                                                      zip2.  */
3842                                                   return 260;
3843                                                 }
3844                                             }
3845                                         }
3846                                     }
3847                                 }
3848                               else
3849                                 {
3850                                   /* 33222222222211111111110000000000
3851                                      10987654321098765432109876543210
3852                                      xxxxxxxxxx0xxxxxxxxxx0xx011101xx
3853                                      ext.  */
3854                                   return 129;
3855                                 }
3856                             }
3857                           else
3858                             {
3859                               if (((word >> 15) & 0x1) == 0)
3860                                 {
3861                                   if (((word >> 22) & 0x1) == 0)
3862                                     {
3863                                       if (((word >> 29) & 0x1) == 0)
3864                                         {
3865                                           if (((word >> 11) & 0x1) == 0)
3866                                             {
3867                                               /* 33222222222211111111110000000000
3868                                                  10987654321098765432109876543210
3869                                                  xxxxxxxxxx10xxx0xxxxx00x011100xx
3870                                                  dup.  */
3871                                               return 146;
3872                                             }
3873                                           else
3874                                             {
3875                                               if (((word >> 12) & 0x1) == 0)
3876                                                 {
3877                                                   if (((word >> 13) & 0x1) == 0)
3878                                                     {
3879                                                       /* 33222222222211111111110000000000
3880                                                          10987654321098765432109876543210
3881                                                          xxxxxxxxxx1100x0xxxxx00x011100xx
3882                                                          dup.  */
3883                                                       return 147;
3884                                                     }
3885                                                   else
3886                                                     {
3887                                                       /* 33222222222211111111110000000000
3888                                                          10987654321098765432109876543210
3889                                                          xxxxxxxxxx1101x0xxxxx00x011100xx
3890                                                          smov.  */
3891                                                       return 148;
3892                                                     }
3893                                                 }
3894                                               else
3895                                                 {
3896                                                   if (((word >> 13) & 0x1) == 0)
3897                                                     {
3898                                                       /* 33222222222211111111110000000000
3899                                                          10987654321098765432109876543210
3900                                                          xxxxxxxxxx1110x0xxxxx00x011100xx
3901                                                          ins.  */
3902                                                       return 151;
3903                                                     }
3904                                                   else
3905                                                     {
3906                                                       /* 33222222222211111111110000000000
3907                                                          10987654321098765432109876543210
3908                                                          xxxxxxxxxx1111x0xxxxx00x011100xx
3909                                                          umov.  */
3910                                                       return 149;
3911                                                     }
3912                                                 }
3913                                             }
3914                                         }
3915                                       else
3916                                         {
3917                                           /* 33222222222211111111110000000000
3918                                              10987654321098765432109876543210
3919                                              xxxxxxxxxx1xxxx0xxxxx00x011101xx
3920                                              ins.  */
3921                                           return 153;
3922                                         }
3923                                     }
3924                                   else
3925                                     {
3926                                       if (((word >> 11) & 0x1) == 0)
3927                                         {
3928                                           if (((word >> 12) & 0x1) == 0)
3929                                             {
3930                                               if (((word >> 13) & 0x1) == 0)
3931                                                 {
3932                                                   if (((word >> 23) & 0x1) == 0)
3933                                                     {
3934                                                       if (((word >> 29) & 0x1) == 0)
3935                                                         {
3936                                                           /* 33222222222211111111110000000000
3937                                                              10987654321098765432109876543210
3938                                                              xxxxxxxxxx1000x0xxxxx010011100xx
3939                                                              fmaxnm.  */
3940                                                           return 285;
3941                                                         }
3942                                                       else
3943                                                         {
3944                                                           /* 33222222222211111111110000000000
3945                                                              10987654321098765432109876543210
3946                                                              xxxxxxxxxx1000x0xxxxx010011101xx
3947                                                              fmaxnmp.  */
3948                                                           return 336;
3949                                                         }
3950                                                     }
3951                                                   else
3952                                                     {
3953                                                       if (((word >> 29) & 0x1) == 0)
3954                                                         {
3955                                                           /* 33222222222211111111110000000000
3956                                                              10987654321098765432109876543210
3957                                                              xxxxxxxxxx1000x0xxxxx011011100xx
3958                                                              fminnm.  */
3959                                                           return 301;
3960                                                         }
3961                                                       else
3962                                                         {
3963                                                           /* 33222222222211111111110000000000
3964                                                              10987654321098765432109876543210
3965                                                              xxxxxxxxxx1000x0xxxxx011011101xx
3966                                                              fminnmp.  */
3967                                                           return 352;
3968                                                         }
3969                                                     }
3970                                                 }
3971                                               else
3972                                                 {
3973                                                   if (((word >> 23) & 0x1) == 0)
3974                                                     {
3975                                                       if (((word >> 29) & 0x1) == 0)
3976                                                         {
3977                                                           /* 33222222222211111111110000000000
3978                                                              10987654321098765432109876543210
3979                                                              xxxxxxxxxx1001x0xxxxx010011100xx
3980                                                              fcmeq.  */
3981                                                           return 293;
3982                                                         }
3983                                                       else
3984                                                         {
3985                                                           /* 33222222222211111111110000000000
3986                                                              10987654321098765432109876543210
3987                                                              xxxxxxxxxx1001x0xxxxx010011101xx
3988                                                              fcmge.  */
3989                                                           return 342;
3990                                                         }
3991                                                     }
3992                                                   else
3993                                                     {
3994                                                       /* 33222222222211111111110000000000
3995                                                          10987654321098765432109876543210
3996                                                          xxxxxxxxxx1001x0xxxxx01101110xxx
3997                                                          fcmgt.  */
3998                                                       return 356;
3999                                                     }
4000                                                 }
4001                                             }
4002                                           else
4003                                             {
4004                                               if (((word >> 13) & 0x1) == 0)
4005                                                 {
4006                                                   if (((word >> 23) & 0x1) == 0)
4007                                                     {
4008                                                       if (((word >> 29) & 0x1) == 0)
4009                                                         {
4010                                                           /* 33222222222211111111110000000000
4011                                                              10987654321098765432109876543210
4012                                                              xxxxxxxxxx1010x0xxxxx010011100xx
4013                                                              fadd.  */
4014                                                           return 289;
4015                                                         }
4016                                                       else
4017                                                         {
4018                                                           /* 33222222222211111111110000000000
4019                                                              10987654321098765432109876543210
4020                                                              xxxxxxxxxx1010x0xxxxx010011101xx
4021                                                              faddp.  */
4022                                                           return 338;
4023                                                         }
4024                                                     }
4025                                                   else
4026                                                     {
4027                                                       if (((word >> 29) & 0x1) == 0)
4028                                                         {
4029                                                           /* 33222222222211111111110000000000
4030                                                              10987654321098765432109876543210
4031                                                              xxxxxxxxxx1010x0xxxxx011011100xx
4032                                                              fsub.  */
4033                                                           return 305;
4034                                                         }
4035                                                       else
4036                                                         {
4037                                                           /* 33222222222211111111110000000000
4038                                                              10987654321098765432109876543210
4039                                                              xxxxxxxxxx1010x0xxxxx011011101xx
4040                                                              fabd.  */
4041                                                           return 354;
4042                                                         }
4043                                                     }
4044                                                 }
4045                                               else
4046                                                 {
4047                                                   if (((word >> 23) & 0x1) == 0)
4048                                                     {
4049                                                       if (((word >> 29) & 0x1) == 0)
4050                                                         {
4051                                                           /* 33222222222211111111110000000000
4052                                                              10987654321098765432109876543210
4053                                                              xxxxxxxxxx1011x0xxxxx010011100xx
4054                                                              fmax.  */
4055                                                           return 295;
4056                                                         }
4057                                                       else
4058                                                         {
4059                                                           /* 33222222222211111111110000000000
4060                                                              10987654321098765432109876543210
4061                                                              xxxxxxxxxx1011x0xxxxx010011101xx
4062                                                              fmaxp.  */
4063                                                           return 346;
4064                                                         }
4065                                                     }
4066                                                   else
4067                                                     {
4068                                                       if (((word >> 29) & 0x1) == 0)
4069                                                         {
4070                                                           /* 33222222222211111111110000000000
4071                                                              10987654321098765432109876543210
4072                                                              xxxxxxxxxx1011x0xxxxx011011100xx
4073                                                              fmin.  */
4074                                                           return 307;
4075                                                         }
4076                                                       else
4077                                                         {
4078                                                           /* 33222222222211111111110000000000
4079                                                              10987654321098765432109876543210
4080                                                              xxxxxxxxxx1011x0xxxxx011011101xx
4081                                                              fminp.  */
4082                                                           return 360;
4083                                                         }
4084                                                     }
4085                                                 }
4086                                             }
4087                                         }
4088                                       else
4089                                         {
4090                                           if (((word >> 12) & 0x1) == 0)
4091                                             {
4092                                               if (((word >> 13) & 0x1) == 0)
4093                                                 {
4094                                                   if (((word >> 23) & 0x1) == 0)
4095                                                     {
4096                                                       /* 33222222222211111111110000000000
4097                                                          10987654321098765432109876543210
4098                                                          xxxxxxxxxx1100x0xxxxx01001110xxx
4099                                                          fmla.  */
4100                                                       return 287;
4101                                                     }
4102                                                   else
4103                                                     {
4104                                                       /* 33222222222211111111110000000000
4105                                                          10987654321098765432109876543210
4106                                                          xxxxxxxxxx1100x0xxxxx01101110xxx
4107                                                          fmls.  */
4108                                                       return 303;
4109                                                     }
4110                                                 }
4111                                               else
4112                                                 {
4113                                                   if (((word >> 23) & 0x1) == 0)
4114                                                     {
4115                                                       /* 33222222222211111111110000000000
4116                                                          10987654321098765432109876543210
4117                                                          xxxxxxxxxx1101x0xxxxx01001110xxx
4118                                                          facge.  */
4119                                                       return 344;
4120                                                     }
4121                                                   else
4122                                                     {
4123                                                       /* 33222222222211111111110000000000
4124                                                          10987654321098765432109876543210
4125                                                          xxxxxxxxxx1101x0xxxxx01101110xxx
4126                                                          facgt.  */
4127                                                       return 358;
4128                                                     }
4129                                                 }
4130                                             }
4131                                           else
4132                                             {
4133                                               if (((word >> 13) & 0x1) == 0)
4134                                                 {
4135                                                   if (((word >> 29) & 0x1) == 0)
4136                                                     {
4137                                                       /* 33222222222211111111110000000000
4138                                                          10987654321098765432109876543210
4139                                                          xxxxxxxxxx1110x0xxxxx01x011100xx
4140                                                          fmulx.  */
4141                                                       return 291;
4142                                                     }
4143                                                   else
4144                                                     {
4145                                                       /* 33222222222211111111110000000000
4146                                                          10987654321098765432109876543210
4147                                                          xxxxxxxxxx1110x0xxxxx01x011101xx
4148                                                          fmul.  */
4149                                                       return 340;
4150                                                     }
4151                                                 }
4152                                               else
4153                                                 {
4154                                                   if (((word >> 23) & 0x1) == 0)
4155                                                     {
4156                                                       if (((word >> 29) & 0x1) == 0)
4157                                                         {
4158                                                           /* 33222222222211111111110000000000
4159                                                              10987654321098765432109876543210
4160                                                              xxxxxxxxxx1111x0xxxxx010011100xx
4161                                                              frecps.  */
4162                                                           return 297;
4163                                                         }
4164                                                       else
4165                                                         {
4166                                                           /* 33222222222211111111110000000000
4167                                                              10987654321098765432109876543210
4168                                                              xxxxxxxxxx1111x0xxxxx010011101xx
4169                                                              fdiv.  */
4170                                                           return 348;
4171                                                         }
4172                                                     }
4173                                                   else
4174                                                     {
4175                                                       /* 33222222222211111111110000000000
4176                                                          10987654321098765432109876543210
4177                                                          xxxxxxxxxx1111x0xxxxx01101110xxx
4178                                                          frsqrts.  */
4179                                                       return 309;
4180                                                     }
4181                                                 }
4182                                             }
4183                                         }
4184                                     }
4185                                 }
4186                               else
4187                                 {
4188                                   if (((word >> 11) & 0x1) == 0)
4189                                     {
4190                                       /* 33222222222211111111110000000000
4191                                          10987654321098765432109876543210
4192                                          xxxxxxxxxx10xxx1xxxxx0xx01110xxx
4193                                          sqrdmlah.  */
4194                                       return 363;
4195                                     }
4196                                   else
4197                                     {
4198                                       /* 33222222222211111111110000000000
4199                                          10987654321098765432109876543210
4200                                          xxxxxxxxxx11xxx1xxxxx0xx01110xxx
4201                                          sqrdmlsh.  */
4202                                       return 364;
4203                                     }
4204                                 }
4205                             }
4206                         }
4207                       else
4208                         {
4209                           if (((word >> 29) & 0x1) == 0)
4210                             {
4211                               if (((word >> 30) & 0x1) == 0)
4212                                 {
4213                                   if (((word >> 16) & 0x1) == 0)
4214                                     {
4215                                       if (((word >> 17) & 0x1) == 0)
4216                                         {
4217                                           /* 33222222222211111111110000000000
4218                                              10987654321098765432109876543210
4219                                              xxxxxxxxxxxxxxxx00xxx0xx0111100x
4220                                              fcvtzs.  */
4221                                           return 718;
4222                                         }
4223                                       else
4224                                         {
4225                                           /* 33222222222211111111110000000000
4226                                              10987654321098765432109876543210
4227                                              xxxxxxxxxxxxxxxx01xxx0xx0111100x
4228                                              scvtf.  */
4229                                           return 714;
4230                                         }
4231                                     }
4232                                   else
4233                                     {
4234                                       if (((word >> 17) & 0x1) == 0)
4235                                         {
4236                                           /* 33222222222211111111110000000000
4237                                              10987654321098765432109876543210
4238                                              xxxxxxxxxxxxxxxx10xxx0xx0111100x
4239                                              fcvtzu.  */
4240                                           return 720;
4241                                         }
4242                                       else
4243                                         {
4244                                           /* 33222222222211111111110000000000
4245                                              10987654321098765432109876543210
4246                                              xxxxxxxxxxxxxxxx11xxx0xx0111100x
4247                                              ucvtf.  */
4248                                           return 716;
4249                                         }
4250                                     }
4251                                 }
4252                               else
4253                                 {
4254                                   if (((word >> 10) & 0x1) == 0)
4255                                     {
4256                                       if (((word >> 12) & 0x1) == 0)
4257                                         {
4258                                           if (((word >> 13) & 0x1) == 0)
4259                                             {
4260                                               if (((word >> 14) & 0x1) == 0)
4261                                                 {
4262                                                   /* 33222222222211111111110000000000
4263                                                      10987654321098765432109876543210
4264                                                      xxxxxxxxxx0x000xxxxxx0xx0111101x
4265                                                      sha1c.  */
4266                                                   return 657;
4267                                                 }
4268                                               else
4269                                                 {
4270                                                   /* 33222222222211111111110000000000
4271                                                      10987654321098765432109876543210
4272                                                      xxxxxxxxxx0x001xxxxxx0xx0111101x
4273                                                      sha256h.  */
4274                                                   return 661;
4275                                                 }
4276                                             }
4277                                           else
4278                                             {
4279                                               if (((word >> 14) & 0x1) == 0)
4280                                                 {
4281                                                   /* 33222222222211111111110000000000
4282                                                      10987654321098765432109876543210
4283                                                      xxxxxxxxxx0x010xxxxxx0xx0111101x
4284                                                      sha1m.  */
4285                                                   return 659;
4286                                                 }
4287                                               else
4288                                                 {
4289                                                   /* 33222222222211111111110000000000
4290                                                      10987654321098765432109876543210
4291                                                      xxxxxxxxxx0x011xxxxxx0xx0111101x
4292                                                      sha256su1.  */
4293                                                   return 663;
4294                                                 }
4295                                             }
4296                                         }
4297                                       else
4298                                         {
4299                                           if (((word >> 13) & 0x1) == 0)
4300                                             {
4301                                               if (((word >> 14) & 0x1) == 0)
4302                                                 {
4303                                                   /* 33222222222211111111110000000000
4304                                                      10987654321098765432109876543210
4305                                                      xxxxxxxxxx0x100xxxxxx0xx0111101x
4306                                                      sha1p.  */
4307                                                   return 658;
4308                                                 }
4309                                               else
4310                                                 {
4311                                                   /* 33222222222211111111110000000000
4312                                                      10987654321098765432109876543210
4313                                                      xxxxxxxxxx0x101xxxxxx0xx0111101x
4314                                                      sha256h2.  */
4315                                                   return 662;
4316                                                 }
4317                                             }
4318                                           else
4319                                             {
4320                                               /* 33222222222211111111110000000000
4321                                                  10987654321098765432109876543210
4322                                                  xxxxxxxxxx0x11xxxxxxx0xx0111101x
4323                                                  sha1su0.  */
4324                                               return 660;
4325                                             }
4326                                         }
4327                                     }
4328                                   else
4329                                     {
4330                                       if (((word >> 11) & 0x1) == 0)
4331                                         {
4332                                           if (((word >> 13) & 0x1) == 0)
4333                                             {
4334                                               /* 33222222222211111111110000000000
4335                                                  10987654321098765432109876543210
4336                                                  xxxxxxxxxx10x0xxxxxxx0xx0111101x
4337                                                  dup.  */
4338                                               return 526;
4339                                             }
4340                                           else
4341                                             {
4342                                               /* 33222222222211111111110000000000
4343                                                  10987654321098765432109876543210
4344                                                  xxxxxxxxxx10x1xxxxxxx0xx0111101x
4345                                                  fcmeq.  */
4346                                               return 547;
4347                                             }
4348                                         }
4349                                       else
4350                                         {
4351                                           if (((word >> 13) & 0x1) == 0)
4352                                             {
4353                                               /* 33222222222211111111110000000000
4354                                                  10987654321098765432109876543210
4355                                                  xxxxxxxxxx11x0xxxxxxx0xx0111101x
4356                                                  fmulx.  */
4357                                               return 545;
4358                                             }
4359                                           else
4360                                             {
4361                                               if (((word >> 23) & 0x1) == 0)
4362                                                 {
4363                                                   /* 33222222222211111111110000000000
4364                                                      10987654321098765432109876543210
4365                                                      xxxxxxxxxx11x1xxxxxxx0x00111101x
4366                                                      frecps.  */
4367                                                   return 549;
4368                                                 }
4369                                               else
4370                                                 {
4371                                                   /* 33222222222211111111110000000000
4372                                                      10987654321098765432109876543210
4373                                                      xxxxxxxxxx11x1xxxxxxx0x10111101x
4374                                                      frsqrts.  */
4375                                                   return 551;
4376                                                 }
4377                                             }
4378                                         }
4379                                     }
4380                                 }
4381                             }
4382                           else
4383                             {
4384                               if (((word >> 11) & 0x1) == 0)
4385                                 {
4386                                   if (((word >> 12) & 0x1) == 0)
4387                                     {
4388                                       if (((word >> 13) & 0x1) == 0)
4389                                         {
4390                                           /* 33222222222211111111110000000000
4391                                              10987654321098765432109876543210
4392                                              xxxxxxxxxxx000xxxxxxx0xx011111xx
4393                                              sqrdmlah.  */
4394                                           return 579;
4395                                         }
4396                                       else
4397                                         {
4398                                           if (((word >> 23) & 0x1) == 0)
4399                                             {
4400                                               /* 33222222222211111111110000000000
4401                                                  10987654321098765432109876543210
4402                                                  xxxxxxxxxxx001xxxxxxx0x0011111xx
4403                                                  fcmge.  */
4404                                               return 564;
4405                                             }
4406                                           else
4407                                             {
4408                                               /* 33222222222211111111110000000000
4409                                                  10987654321098765432109876543210
4410                                                  xxxxxxxxxxx001xxxxxxx0x1011111xx
4411                                                  fcmgt.  */
4412                                               return 570;
4413                                             }
4414                                         }
4415                                     }
4416                                   else
4417                                     {
4418                                       /* 33222222222211111111110000000000
4419                                          10987654321098765432109876543210
4420                                          xxxxxxxxxxx01xxxxxxxx0xx011111xx
4421                                          fabd.  */
4422                                       return 568;
4423                                     }
4424                                 }
4425                               else
4426                                 {
4427                                   if (((word >> 13) & 0x1) == 0)
4428                                     {
4429                                       /* 33222222222211111111110000000000
4430                                          10987654321098765432109876543210
4431                                          xxxxxxxxxxx1x0xxxxxxx0xx011111xx
4432                                          sqrdmlsh.  */
4433                                       return 580;
4434                                     }
4435                                   else
4436                                     {
4437                                       if (((word >> 23) & 0x1) == 0)
4438                                         {
4439                                           /* 33222222222211111111110000000000
4440                                              10987654321098765432109876543210
4441                                              xxxxxxxxxxx1x1xxxxxxx0x0011111xx
4442                                              facge.  */
4443                                           return 566;
4444                                         }
4445                                       else
4446                                         {
4447                                           /* 33222222222211111111110000000000
4448                                              10987654321098765432109876543210
4449                                              xxxxxxxxxxx1x1xxxxxxx0x1011111xx
4450                                              facgt.  */
4451                                           return 572;
4452                                         }
4453                                     }
4454                                 }
4455                             }
4456                         }
4457                     }
4458                   else
4459                     {
4460                       if (((word >> 10) & 0x1) == 0)
4461                         {
4462                           if (((word >> 11) & 0x1) == 0)
4463                             {
4464                               if (((word >> 12) & 0x1) == 0)
4465                                 {
4466                                   if (((word >> 13) & 0x1) == 0)
4467                                     {
4468                                       if (((word >> 14) & 0x1) == 0)
4469                                         {
4470                                           if (((word >> 15) & 0x1) == 0)
4471                                             {
4472                                               if (((word >> 28) & 0x1) == 0)
4473                                                 {
4474                                                   if (((word >> 29) & 0x1) == 0)
4475                                                     {
4476                                                       if (((word >> 30) & 0x1) == 0)
4477                                                         {
4478                                                           /* 33222222222211111111110000000000
4479                                                              10987654321098765432109876543210
4480                                                              xxxxxxxxxx000000xxxxx1xx0111000x
4481                                                              saddl.  */
4482                                                           return 42;
4483                                                         }
4484                                                       else
4485                                                         {
4486                                                           /* 33222222222211111111110000000000
4487                                                              10987654321098765432109876543210
4488                                                              xxxxxxxxxx000000xxxxx1xx0111001x
4489                                                              saddl2.  */
4490                                                           return 43;
4491                                                         }
4492                                                     }
4493                                                   else
4494                                                     {
4495                                                       if (((word >> 30) & 0x1) == 0)
4496                                                         {
4497                                                           /* 33222222222211111111110000000000
4498                                                              10987654321098765432109876543210
4499                                                              xxxxxxxxxx000000xxxxx1xx0111010x
4500                                                              uaddl.  */
4501                                                           return 74;
4502                                                         }
4503                                                       else
4504                                                         {
4505                                                           /* 33222222222211111111110000000000
4506                                                              10987654321098765432109876543210
4507                                                              xxxxxxxxxx000000xxxxx1xx0111011x
4508                                                              uaddl2.  */
4509                                                           return 75;
4510                                                         }
4511                                                     }
4512                                                 }
4513                                               else
4514                                                 {
4515                                                   if (((word >> 16) & 0x1) == 0)
4516                                                     {
4517                                                       if (((word >> 17) & 0x1) == 0)
4518                                                         {
4519                                                           if (((word >> 18) & 0x1) == 0)
4520                                                             {
4521                                                               if (((word >> 19) & 0x1) == 0)
4522                                                                 {
4523                                                                   if (((word >> 20) & 0x1) == 0)
4524                                                                     {
4525                                                                       /* 33222222222211111111110000000000
4526                                                                          10987654321098765432109876543210
4527                                                                          xxxxxxxxxx000000000001xx01111xxx
4528                                                                          fcvtns.  */
4529                                                                       return 722;
4530                                                                     }
4531                                                                   else
4532                                                                     {
4533                                                                       /* 33222222222211111111110000000000
4534                                                                          10987654321098765432109876543210
4535                                                                          xxxxxxxxxx000000000011xx01111xxx
4536                                                                          fcvtms.  */
4537                                                                       return 742;
4538                                                                     }
4539                                                                 }
4540                                                               else
4541                                                                 {
4542                                                                   if (((word >> 20) & 0x1) == 0)
4543                                                                     {
4544                                                                       /* 33222222222211111111110000000000
4545                                                                          10987654321098765432109876543210
4546                                                                          xxxxxxxxxx000000000101xx01111xxx
4547                                                                          fcvtps.  */
4548                                                                       return 738;
4549                                                                     }
4550                                                                   else
4551                                                                     {
4552                                                                       /* 33222222222211111111110000000000
4553                                                                          10987654321098765432109876543210
4554                                                                          xxxxxxxxxx000000000111xx01111xxx
4555                                                                          fcvtzs.  */
4556                                                                       return 746;
4557                                                                     }
4558                                                                 }
4559                                                             }
4560                                                           else
4561                                                             {
4562                                                               /* 33222222222211111111110000000000
4563                                                                  10987654321098765432109876543210
4564                                                                  xxxxxxxxxx000000001xx1xx01111xxx
4565                                                                  fcvtas.  */
4566                                                               return 730;
4567                                                             }
4568                                                         }
4569                                                       else
4570                                                         {
4571                                                           if (((word >> 18) & 0x1) == 0)
4572                                                             {
4573                                                               /* 33222222222211111111110000000000
4574                                                                  10987654321098765432109876543210
4575                                                                  xxxxxxxxxx000000010xx1xx01111xxx
4576                                                                  scvtf.  */
4577                                                               return 726;
4578                                                             }
4579                                                           else
4580                                                             {
4581                                                               if (((word >> 19) & 0x1) == 0)
4582                                                                 {
4583                                                                   /* 33222222222211111111110000000000
4584                                                                      10987654321098765432109876543210
4585                                                                      xxxxxxxxxx0000000110x1xx01111xxx
4586                                                                      fmov.  */
4587                                                                   return 734;
4588                                                                 }
4589                                                               else
4590                                                                 {
4591                                                                   /* 33222222222211111111110000000000
4592                                                                      10987654321098765432109876543210
4593                                                                      xxxxxxxxxx0000000111x1xx01111xxx
4594                                                                      fmov.  */
4595                                                                   return 750;
4596                                                                 }
4597                                                             }
4598                                                         }
4599                                                     }
4600                                                   else
4601                                                     {
4602                                                       if (((word >> 17) & 0x1) == 0)
4603                                                         {
4604                                                           if (((word >> 18) & 0x1) == 0)
4605                                                             {
4606                                                               if (((word >> 19) & 0x1) == 0)
4607                                                                 {
4608                                                                   if (((word >> 20) & 0x1) == 0)
4609                                                                     {
4610                                                                       /* 33222222222211111111110000000000
4611                                                                          10987654321098765432109876543210
4612                                                                          xxxxxxxxxx000000100001xx01111xxx
4613                                                                          fcvtnu.  */
4614                                                                       return 724;
4615                                                                     }
4616                                                                   else
4617                                                                     {
4618                                                                       /* 33222222222211111111110000000000
4619                                                                          10987654321098765432109876543210
4620                                                                          xxxxxxxxxx000000100011xx01111xxx
4621                                                                          fcvtmu.  */
4622                                                                       return 744;
4623                                                                     }
4624                                                                 }
4625                                                               else
4626                                                                 {
4627                                                                   if (((word >> 20) & 0x1) == 0)
4628                                                                     {
4629                                                                       /* 33222222222211111111110000000000
4630                                                                          10987654321098765432109876543210
4631                                                                          xxxxxxxxxx000000100101xx01111xxx
4632                                                                          fcvtpu.  */
4633                                                                       return 740;
4634                                                                     }
4635                                                                   else
4636                                                                     {
4637                                                                       /* 33222222222211111111110000000000
4638                                                                          10987654321098765432109876543210
4639                                                                          xxxxxxxxxx000000100111xx01111xxx
4640                                                                          fcvtzu.  */
4641                                                                       return 748;
4642                                                                     }
4643                                                                 }
4644                                                             }
4645                                                           else
4646                                                             {
4647                                                               /* 33222222222211111111110000000000
4648                                                                  10987654321098765432109876543210
4649                                                                  xxxxxxxxxx000000101xx1xx01111xxx
4650                                                                  fcvtau.  */
4651                                                               return 732;
4652                                                             }
4653                                                         }
4654                                                       else
4655                                                         {
4656                                                           if (((word >> 18) & 0x1) == 0)
4657                                                             {
4658                                                               /* 33222222222211111111110000000000
4659                                                                  10987654321098765432109876543210
4660                                                                  xxxxxxxxxx000000110xx1xx01111xxx
4661                                                                  ucvtf.  */
4662                                                               return 728;
4663                                                             }
4664                                                           else
4665                                                             {
4666                                                               if (((word >> 19) & 0x1) == 0)
4667                                                                 {
4668                                                                   /* 33222222222211111111110000000000
4669                                                                      10987654321098765432109876543210
4670                                                                      xxxxxxxxxx0000001110x1xx01111xxx
4671                                                                      fmov.  */
4672                                                                   return 736;
4673                                                                 }
4674                                                               else
4675                                                                 {
4676                                                                   /* 33222222222211111111110000000000
4677                                                                      10987654321098765432109876543210
4678                                                                      xxxxxxxxxx0000001111x1xx01111xxx
4679                                                                      fmov.  */
4680                                                                   return 751;
4681                                                                 }
4682                                                             }
4683                                                         }
4684                                                     }
4685                                                 }
4686                                             }
4687                                           else
4688                                             {
4689                                               if (((word >> 29) & 0x1) == 0)
4690                                                 {
4691                                                   if (((word >> 30) & 0x1) == 0)
4692                                                     {
4693                                                       /* 33222222222211111111110000000000
4694                                                          10987654321098765432109876543210
4695                                                          xxxxxxxxxx000001xxxxx1xx0111x00x
4696                                                          smlal.  */
4697                                                       return 58;
4698                                                     }
4699                                                   else
4700                                                     {
4701                                                       /* 33222222222211111111110000000000
4702                                                          10987654321098765432109876543210
4703                                                          xxxxxxxxxx000001xxxxx1xx0111x01x
4704                                                          smlal2.  */
4705                                                       return 59;
4706                                                     }
4707                                                 }
4708                                               else
4709                                                 {
4710                                                   if (((word >> 30) & 0x1) == 0)
4711                                                     {
4712                                                       /* 33222222222211111111110000000000
4713                                                          10987654321098765432109876543210
4714                                                          xxxxxxxxxx000001xxxxx1xx0111x10x
4715                                                          umlal.  */
4716                                                       return 90;
4717                                                     }
4718                                                   else
4719                                                     {
4720                                                       /* 33222222222211111111110000000000
4721                                                          10987654321098765432109876543210
4722                                                          xxxxxxxxxx000001xxxxx1xx0111x11x
4723                                                          umlal2.  */
4724                                                       return 91;
4725                                                     }
4726                                                 }
4727                                             }
4728                                         }
4729                                       else
4730                                         {
4731                                           if (((word >> 28) & 0x1) == 0)
4732                                             {
4733                                               if (((word >> 15) & 0x1) == 0)
4734                                                 {
4735                                                   if (((word >> 29) & 0x1) == 0)
4736                                                     {
4737                                                       if (((word >> 30) & 0x1) == 0)
4738                                                         {
4739                                                           /* 33222222222211111111110000000000
4740                                                              10987654321098765432109876543210
4741                                                              xxxxxxxxxx000010xxxxx1xx0111000x
4742                                                              addhn.  */
4743                                                           return 50;
4744                                                         }
4745                                                       else
4746                                                         {
4747                                                           /* 33222222222211111111110000000000
4748                                                              10987654321098765432109876543210
4749                                                              xxxxxxxxxx000010xxxxx1xx0111001x
4750                                                              addhn2.  */
4751                                                           return 51;
4752                                                         }
4753                                                     }
4754                                                   else
4755                                                     {
4756                                                       if (((word >> 30) & 0x1) == 0)
4757                                                         {
4758                                                           /* 33222222222211111111110000000000
4759                                                              10987654321098765432109876543210
4760                                                              xxxxxxxxxx000010xxxxx1xx0111010x
4761                                                              raddhn.  */
4762                                                           return 82;
4763                                                         }
4764                                                       else
4765                                                         {
4766                                                           /* 33222222222211111111110000000000
4767                                                              10987654321098765432109876543210
4768                                                              xxxxxxxxxx000010xxxxx1xx0111011x
4769                                                              raddhn2.  */
4770                                                           return 83;
4771                                                         }
4772                                                     }
4773                                                 }
4774                                               else
4775                                                 {
4776                                                   if (((word >> 29) & 0x1) == 0)
4777                                                     {
4778                                                       if (((word >> 30) & 0x1) == 0)
4779                                                         {
4780                                                           /* 33222222222211111111110000000000
4781                                                              10987654321098765432109876543210
4782                                                              xxxxxxxxxx000011xxxxx1xx0111000x
4783                                                              smull.  */
4784                                                           return 66;
4785                                                         }
4786                                                       else
4787                                                         {
4788                                                           /* 33222222222211111111110000000000
4789                                                              10987654321098765432109876543210
4790                                                              xxxxxxxxxx000011xxxxx1xx0111001x
4791                                                              smull2.  */
4792                                                           return 67;
4793                                                         }
4794                                                     }
4795                                                   else
4796                                                     {
4797                                                       if (((word >> 30) & 0x1) == 0)
4798                                                         {
4799                                                           /* 33222222222211111111110000000000
4800                                                              10987654321098765432109876543210
4801                                                              xxxxxxxxxx000011xxxxx1xx0111010x
4802                                                              umull.  */
4803                                                           return 94;
4804                                                         }
4805                                                       else
4806                                                         {
4807                                                           /* 33222222222211111111110000000000
4808                                                              10987654321098765432109876543210
4809                                                              xxxxxxxxxx000011xxxxx1xx0111011x
4810                                                              umull2.  */
4811                                                           return 95;
4812                                                         }
4813                                                     }
4814                                                 }
4815                                             }
4816                                           else
4817                                             {
4818                                               if (((word >> 17) & 0x1) == 0)
4819                                                 {
4820                                                   if (((word >> 15) & 0x1) == 0)
4821                                                     {
4822                                                       if (((word >> 16) & 0x1) == 0)
4823                                                         {
4824                                                           if (((word >> 18) & 0x1) == 0)
4825                                                             {
4826                                                               /* 33222222222211111111110000000000
4827                                                                  10987654321098765432109876543210
4828                                                                  xxxxxxxxxx000010000xx1xx01111xxx
4829                                                                  fmov.  */
4830                                                               return 764;
4831                                                             }
4832                                                           else
4833                                                             {
4834                                                               /* 33222222222211111111110000000000
4835                                                                  10987654321098765432109876543210
4836                                                                  xxxxxxxxxx000010001xx1xx01111xxx
4837                                                                  frintn.  */
4838                                                               return 773;
4839                                                             }
4840                                                         }
4841                                                       else
4842                                                         {
4843                                                           if (((word >> 18) & 0x1) == 0)
4844                                                             {
4845                                                               /* 33222222222211111111110000000000
4846                                                                  10987654321098765432109876543210
4847                                                                  xxxxxxxxxx000010100xx1xx01111xxx
4848                                                                  fneg.  */
4849                                                               return 768;
4850                                                             }
4851                                                           else
4852                                                             {
4853                                                               /* 33222222222211111111110000000000
4854                                                                  10987654321098765432109876543210
4855                                                                  xxxxxxxxxx000010101xx1xx01111xxx
4856                                                                  frintm.  */
4857                                                               return 777;
4858                                                             }
4859                                                         }
4860                                                     }
4861                                                   else
4862                                                     {
4863                                                       if (((word >> 16) & 0x1) == 0)
4864                                                         {
4865                                                           if (((word >> 18) & 0x1) == 0)
4866                                                             {
4867                                                               /* 33222222222211111111110000000000
4868                                                                  10987654321098765432109876543210
4869                                                                  xxxxxxxxxx000011000xx1xx01111xxx
4870                                                                  fabs.  */
4871                                                               return 766;
4872                                                             }
4873                                                           else
4874                                                             {
4875                                                               /* 33222222222211111111110000000000
4876                                                                  10987654321098765432109876543210
4877                                                                  xxxxxxxxxx000011001xx1xx01111xxx
4878                                                                  frintp.  */
4879                                                               return 775;
4880                                                             }
4881                                                         }
4882                                                       else
4883                                                         {
4884                                                           if (((word >> 18) & 0x1) == 0)
4885                                                             {
4886                                                               /* 33222222222211111111110000000000
4887                                                                  10987654321098765432109876543210
4888                                                                  xxxxxxxxxx000011100xx1xx01111xxx
4889                                                                  fsqrt.  */
4890                                                               return 770;
4891                                                             }
4892                                                           else
4893                                                             {
4894                                                               /* 33222222222211111111110000000000
4895                                                                  10987654321098765432109876543210
4896                                                                  xxxxxxxxxx000011101xx1xx01111xxx
4897                                                                  frintz.  */
4898                                                               return 779;
4899                                                             }
4900                                                         }
4901                                                     }
4902                                                 }
4903                                               else
4904                                                 {
4905                                                   if (((word >> 18) & 0x1) == 0)
4906                                                     {
4907                                                       /* 33222222222211111111110000000000
4908                                                          10987654321098765432109876543210
4909                                                          xxxxxxxxxx00001xx10xx1xx01111xxx
4910                                                          fcvt.  */
4911                                                       return 772;
4912                                                     }
4913                                                   else
4914                                                     {
4915                                                       if (((word >> 15) & 0x1) == 0)
4916                                                         {
4917                                                           if (((word >> 16) & 0x1) == 0)
4918                                                             {
4919                                                               /* 33222222222211111111110000000000
4920                                                                  10987654321098765432109876543210
4921                                                                  xxxxxxxxxx000010011xx1xx01111xxx
4922                                                                  frinta.  */
4923                                                               return 781;
4924                                                             }
4925                                                           else
4926                                                             {
4927                                                               /* 33222222222211111111110000000000
4928                                                                  10987654321098765432109876543210
4929                                                                  xxxxxxxxxx000010111xx1xx01111xxx
4930                                                                  frintx.  */
4931                                                               return 783;
4932                                                             }
4933                                                         }
4934                                                       else
4935                                                         {
4936                                                           /* 33222222222211111111110000000000
4937                                                              10987654321098765432109876543210
4938                                                              xxxxxxxxxx000011x11xx1xx01111xxx
4939                                                              frinti.  */
4940                                                           return 785;
4941                                                         }
4942                                                     }
4943                                                 }
4944                                             }
4945                                         }
4946                                     }
4947                                   else
4948                                     {
4949                                       if (((word >> 14) & 0x1) == 0)
4950                                         {
4951                                           if (((word >> 15) & 0x1) == 0)
4952                                             {
4953                                               if (((word >> 28) & 0x1) == 0)
4954                                                 {
4955                                                   if (((word >> 29) & 0x1) == 0)
4956                                                     {
4957                                                       if (((word >> 30) & 0x1) == 0)
4958                                                         {
4959                                                           /* 33222222222211111111110000000000
4960                                                              10987654321098765432109876543210
4961                                                              xxxxxxxxxx000100xxxxx1xx0111000x
4962                                                              ssubl.  */
4963                                                           return 46;
4964                                                         }
4965                                                       else
4966                                                         {
4967                                                           /* 33222222222211111111110000000000
4968                                                              10987654321098765432109876543210
4969                                                              xxxxxxxxxx000100xxxxx1xx0111001x
4970                                                              ssubl2.  */
4971                                                           return 47;
4972                                                         }
4973                                                     }
4974                                                   else
4975                                                     {
4976                                                       if (((word >> 30) & 0x1) == 0)
4977                                                         {
4978                                                           /* 33222222222211111111110000000000
4979                                                              10987654321098765432109876543210
4980                                                              xxxxxxxxxx000100xxxxx1xx0111010x
4981                                                              usubl.  */
4982                                                           return 78;
4983                                                         }
4984                                                       else
4985                                                         {
4986                                                           /* 33222222222211111111110000000000
4987                                                              10987654321098765432109876543210
4988                                                              xxxxxxxxxx000100xxxxx1xx0111011x
4989                                                              usubl2.  */
4990                                                           return 79;
4991                                                         }
4992                                                     }
4993                                                 }
4994                                               else
4995                                                 {
4996                                                   if (((word >> 3) & 0x1) == 0)
4997                                                     {
4998                                                       if (((word >> 4) & 0x1) == 0)
4999                                                         {
5000                                                           /* 33222222222211111111110000000000
5001                                                              10987654321098765432109876543210
5002                                                              xxx00xxxxx000100xxxxx1xx01111xxx
5003                                                              fcmp.  */
5004                                                           return 756;
5005                                                         }
5006                                                       else
5007                                                         {
5008                                                           /* 33222222222211111111110000000000
5009                                                              10987654321098765432109876543210
5010                                                              xxx01xxxxx000100xxxxx1xx01111xxx
5011                                                              fcmpe.  */
5012                                                           return 758;
5013                                                         }
5014                                                     }
5015                                                   else
5016                                                     {
5017                                                       if (((word >> 4) & 0x1) == 0)
5018                                                         {
5019                                                           /* 33222222222211111111110000000000
5020                                                              10987654321098765432109876543210
5021                                                              xxx10xxxxx000100xxxxx1xx01111xxx
5022                                                              fcmp.  */
5023                                                           return 760;
5024                                                         }
5025                                                       else
5026                                                         {
5027                                                           /* 33222222222211111111110000000000
5028                                                              10987654321098765432109876543210
5029                                                              xxx11xxxxx000100xxxxx1xx01111xxx
5030                                                              fcmpe.  */
5031                                                           return 762;
5032                                                         }
5033                                                     }
5034                                                 }
5035                                             }
5036                                           else
5037                                             {
5038                                               if (((word >> 29) & 0x1) == 0)
5039                                                 {
5040                                                   if (((word >> 30) & 0x1) == 0)
5041                                                     {
5042                                                       /* 33222222222211111111110000000000
5043                                                          10987654321098765432109876543210
5044                                                          xxxxxxxxxx000101xxxxx1xx0111x00x
5045                                                          smlsl.  */
5046                                                       return 62;
5047                                                     }
5048                                                   else
5049                                                     {
5050                                                       /* 33222222222211111111110000000000
5051                                                          10987654321098765432109876543210
5052                                                          xxxxxxxxxx000101xxxxx1xx0111x01x
5053                                                          smlsl2.  */
5054                                                       return 63;
5055                                                     }
5056                                                 }
5057                                               else
5058                                                 {
5059                                                   if (((word >> 30) & 0x1) == 0)
5060                                                     {
5061                                                       /* 33222222222211111111110000000000
5062                                                          10987654321098765432109876543210
5063                                                          xxxxxxxxxx000101xxxxx1xx0111x10x
5064                                                          umlsl.  */
5065                                                       return 92;
5066                                                     }
5067                                                   else
5068                                                     {
5069                                                       /* 33222222222211111111110000000000
5070                                                          10987654321098765432109876543210
5071                                                          xxxxxxxxxx000101xxxxx1xx0111x11x
5072                                                          umlsl2.  */
5073                                                       return 93;
5074                                                     }
5075                                                 }
5076                                             }
5077                                         }
5078                                       else
5079                                         {
5080                                           if (((word >> 15) & 0x1) == 0)
5081                                             {
5082                                               if (((word >> 29) & 0x1) == 0)
5083                                                 {
5084                                                   if (((word >> 30) & 0x1) == 0)
5085                                                     {
5086                                                       /* 33222222222211111111110000000000
5087                                                          10987654321098765432109876543210
5088                                                          xxxxxxxxxx000110xxxxx1xx0111x00x
5089                                                          subhn.  */
5090                                                       return 54;
5091                                                     }
5092                                                   else
5093                                                     {
5094                                                       /* 33222222222211111111110000000000
5095                                                          10987654321098765432109876543210
5096                                                          xxxxxxxxxx000110xxxxx1xx0111x01x
5097                                                          subhn2.  */
5098                                                       return 55;
5099                                                     }
5100                                                 }
5101                                               else
5102                                                 {
5103                                                   if (((word >> 30) & 0x1) == 0)
5104                                                     {
5105                                                       /* 33222222222211111111110000000000
5106                                                          10987654321098765432109876543210
5107                                                          xxxxxxxxxx000110xxxxx1xx0111x10x
5108                                                          rsubhn.  */
5109                                                       return 86;
5110                                                     }
5111                                                   else
5112                                                     {
5113                                                       /* 33222222222211111111110000000000
5114                                                          10987654321098765432109876543210
5115                                                          xxxxxxxxxx000110xxxxx1xx0111x11x
5116                                                          rsubhn2.  */
5117                                                       return 87;
5118                                                     }
5119                                                 }
5120                                             }
5121                                           else
5122                                             {
5123                                               if (((word >> 22) & 0x1) == 0)
5124                                                 {
5125                                                   if (((word >> 30) & 0x1) == 0)
5126                                                     {
5127                                                       /* 33222222222211111111110000000000
5128                                                          10987654321098765432109876543210
5129                                                          xxxxxxxxxx000111xxxxx10x0111xx0x
5130                                                          pmull.  */
5131                                                       return 70;
5132                                                     }
5133                                                   else
5134                                                     {
5135                                                       /* 33222222222211111111110000000000
5136                                                          10987654321098765432109876543210
5137                                                          xxxxxxxxxx000111xxxxx10x0111xx1x
5138                                                          pmull2.  */
5139                                                       return 72;
5140                                                     }
5141                                                 }
5142                                               else
5143                                                 {
5144                                                   if (((word >> 30) & 0x1) == 0)
5145                                                     {
5146                                                       /* 33222222222211111111110000000000
5147                                                          10987654321098765432109876543210
5148                                                          xxxxxxxxxx000111xxxxx11x0111xx0x
5149                                                          pmull.  */
5150                                                       return 71;
5151                                                     }
5152                                                   else
5153                                                     {
5154                                                       /* 33222222222211111111110000000000
5155                                                          10987654321098765432109876543210
5156                                                          xxxxxxxxxx000111xxxxx11x0111xx1x
5157                                                          pmull2.  */
5158                                                       return 73;
5159                                                     }
5160                                                 }
5161                                             }
5162                                         }
5163                                     }
5164                                 }
5165                               else
5166                                 {
5167                                   if (((word >> 28) & 0x1) == 0)
5168                                     {
5169                                       if (((word >> 13) & 0x1) == 0)
5170                                         {
5171                                           if (((word >> 14) & 0x1) == 0)
5172                                             {
5173                                               if (((word >> 15) & 0x1) == 0)
5174                                                 {
5175                                                   if (((word >> 29) & 0x1) == 0)
5176                                                     {
5177                                                       if (((word >> 30) & 0x1) == 0)
5178                                                         {
5179                                                           /* 33222222222211111111110000000000
5180                                                              10987654321098765432109876543210
5181                                                              xxxxxxxxxx001000xxxxx1xx0111000x
5182                                                              saddw.  */
5183                                                           return 44;
5184                                                         }
5185                                                       else
5186                                                         {
5187                                                           /* 33222222222211111111110000000000
5188                                                              10987654321098765432109876543210
5189                                                              xxxxxxxxxx001000xxxxx1xx0111001x
5190                                                              saddw2.  */
5191                                                           return 45;
5192                                                         }
5193                                                     }
5194                                                   else
5195                                                     {
5196                                                       if (((word >> 30) & 0x1) == 0)
5197                                                         {
5198                                                           /* 33222222222211111111110000000000
5199                                                              10987654321098765432109876543210
5200                                                              xxxxxxxxxx001000xxxxx1xx0111010x
5201                                                              uaddw.  */
5202                                                           return 76;
5203                                                         }
5204                                                       else
5205                                                         {
5206                                                           /* 33222222222211111111110000000000
5207                                                              10987654321098765432109876543210
5208                                                              xxxxxxxxxx001000xxxxx1xx0111011x
5209                                                              uaddw2.  */
5210                                                           return 77;
5211                                                         }
5212                                                     }
5213                                                 }
5214                                               else
5215                                                 {
5216                                                   if (((word >> 30) & 0x1) == 0)
5217                                                     {
5218                                                       /* 33222222222211111111110000000000
5219                                                          10987654321098765432109876543210
5220                                                          xxxxxxxxxx001001xxxxx1xx01110x0x
5221                                                          sqdmlal.  */
5222                                                       return 60;
5223                                                     }
5224                                                   else
5225                                                     {
5226                                                       /* 33222222222211111111110000000000
5227                                                          10987654321098765432109876543210
5228                                                          xxxxxxxxxx001001xxxxx1xx01110x1x
5229                                                          sqdmlal2.  */
5230                                                       return 61;
5231                                                     }
5232                                                 }
5233                                             }
5234                                           else
5235                                             {
5236                                               if (((word >> 15) & 0x1) == 0)
5237                                                 {
5238                                                   if (((word >> 29) & 0x1) == 0)
5239                                                     {
5240                                                       if (((word >> 30) & 0x1) == 0)
5241                                                         {
5242                                                           /* 33222222222211111111110000000000
5243                                                              10987654321098765432109876543210
5244                                                              xxxxxxxxxx001010xxxxx1xx0111000x
5245                                                              sabal.  */
5246                                                           return 52;
5247                                                         }
5248                                                       else
5249                                                         {
5250                                                           /* 33222222222211111111110000000000
5251                                                              10987654321098765432109876543210
5252                                                              xxxxxxxxxx001010xxxxx1xx0111001x
5253                                                              sabal2.  */
5254                                                           return 53;
5255                                                         }
5256                                                     }
5257                                                   else
5258                                                     {
5259                                                       if (((word >> 30) & 0x1) == 0)
5260                                                         {
5261                                                           /* 33222222222211111111110000000000
5262                                                              10987654321098765432109876543210
5263                                                              xxxxxxxxxx001010xxxxx1xx0111010x
5264                                                              uabal.  */
5265                                                           return 84;
5266                                                         }
5267                                                       else
5268                                                         {
5269                                                           /* 33222222222211111111110000000000
5270                                                              10987654321098765432109876543210
5271                                                              xxxxxxxxxx001010xxxxx1xx0111011x
5272                                                              uabal2.  */
5273                                                           return 85;
5274                                                         }
5275                                                     }
5276                                                 }
5277                                               else
5278                                                 {
5279                                                   if (((word >> 30) & 0x1) == 0)
5280                                                     {
5281                                                       /* 33222222222211111111110000000000
5282                                                          10987654321098765432109876543210
5283                                                          xxxxxxxxxx001011xxxxx1xx01110x0x
5284                                                          sqdmull.  */
5285                                                       return 68;
5286                                                     }
5287                                                   else
5288                                                     {
5289                                                       /* 33222222222211111111110000000000
5290                                                          10987654321098765432109876543210
5291                                                          xxxxxxxxxx001011xxxxx1xx01110x1x
5292                                                          sqdmull2.  */
5293                                                       return 69;
5294                                                     }
5295                                                 }
5296                                             }
5297                                         }
5298                                       else
5299                                         {
5300                                           if (((word >> 14) & 0x1) == 0)
5301                                             {
5302                                               if (((word >> 15) & 0x1) == 0)
5303                                                 {
5304                                                   if (((word >> 29) & 0x1) == 0)
5305                                                     {
5306                                                       if (((word >> 30) & 0x1) == 0)
5307                                                         {
5308                                                           /* 33222222222211111111110000000000
5309                                                              10987654321098765432109876543210
5310                                                              xxxxxxxxxx001100xxxxx1xx0111000x
5311                                                              ssubw.  */
5312                                                           return 48;
5313                                                         }
5314                                                       else
5315                                                         {
5316                                                           /* 33222222222211111111110000000000
5317                                                              10987654321098765432109876543210
5318                                                              xxxxxxxxxx001100xxxxx1xx0111001x
5319                                                              ssubw2.  */
5320                                                           return 49;
5321                                                         }
5322                                                     }
5323                                                   else
5324                                                     {
5325                                                       if (((word >> 30) & 0x1) == 0)
5326                                                         {
5327                                                           /* 33222222222211111111110000000000
5328                                                              10987654321098765432109876543210
5329                                                              xxxxxxxxxx001100xxxxx1xx0111010x
5330                                                              usubw.  */
5331                                                           return 80;
5332                                                         }
5333                                                       else
5334                                                         {
5335                                                           /* 33222222222211111111110000000000
5336                                                              10987654321098765432109876543210
5337                                                              xxxxxxxxxx001100xxxxx1xx0111011x
5338                                                              usubw2.  */
5339                                                           return 81;
5340                                                         }
5341                                                     }
5342                                                 }
5343                                               else
5344                                                 {
5345                                                   if (((word >> 30) & 0x1) == 0)
5346                                                     {
5347                                                       /* 33222222222211111111110000000000
5348                                                          10987654321098765432109876543210
5349                                                          xxxxxxxxxx001101xxxxx1xx01110x0x
5350                                                          sqdmlsl.  */
5351                                                       return 64;
5352                                                     }
5353                                                   else
5354                                                     {
5355                                                       /* 33222222222211111111110000000000
5356                                                          10987654321098765432109876543210
5357                                                          xxxxxxxxxx001101xxxxx1xx01110x1x
5358                                                          sqdmlsl2.  */
5359                                                       return 65;
5360                                                     }
5361                                                 }
5362                                             }
5363                                           else
5364                                             {
5365                                               if (((word >> 29) & 0x1) == 0)
5366                                                 {
5367                                                   if (((word >> 30) & 0x1) == 0)
5368                                                     {
5369                                                       /* 33222222222211111111110000000000
5370                                                          10987654321098765432109876543210
5371                                                          xxxxxxxxxx00111xxxxxx1xx0111000x
5372                                                          sabdl.  */
5373                                                       return 56;
5374                                                     }
5375                                                   else
5376                                                     {
5377                                                       /* 33222222222211111111110000000000
5378                                                          10987654321098765432109876543210
5379                                                          xxxxxxxxxx00111xxxxxx1xx0111001x
5380                                                          sabdl2.  */
5381                                                       return 57;
5382                                                     }
5383                                                 }
5384                                               else
5385                                                 {
5386                                                   if (((word >> 30) & 0x1) == 0)
5387                                                     {
5388                                                       /* 33222222222211111111110000000000
5389                                                          10987654321098765432109876543210
5390                                                          xxxxxxxxxx00111xxxxxx1xx0111010x
5391                                                          uabdl.  */
5392                                                       return 88;
5393                                                     }
5394                                                   else
5395                                                     {
5396                                                       /* 33222222222211111111110000000000
5397                                                          10987654321098765432109876543210
5398                                                          xxxxxxxxxx00111xxxxxx1xx0111011x
5399                                                          uabdl2.  */
5400                                                       return 89;
5401                                                     }
5402                                                 }
5403                                             }
5404                                         }
5405                                     }
5406                                   else
5407                                     {
5408                                       if (((word >> 30) & 0x1) == 0)
5409                                         {
5410                                           /* 33222222222211111111110000000000
5411                                              10987654321098765432109876543210
5412                                              xxxxxxxxxx001xxxxxxxx1xx01111x0x
5413                                              fmov.  */
5414                                           return 813;
5415                                         }
5416                                       else
5417                                         {
5418                                           if (((word >> 13) & 0x1) == 0)
5419                                             {
5420                                               if (((word >> 14) & 0x1) == 0)
5421                                                 {
5422                                                   /* 33222222222211111111110000000000
5423                                                      10987654321098765432109876543210
5424                                                      xxxxxxxxxx00100xxxxxx1xx01111x1x
5425                                                      sqdmlal.  */
5426                                                   return 413;
5427                                                 }
5428                                               else
5429                                                 {
5430                                                   /* 33222222222211111111110000000000
5431                                                      10987654321098765432109876543210
5432                                                      xxxxxxxxxx00101xxxxxx1xx01111x1x
5433                                                      sqdmull.  */
5434                                                   return 415;
5435                                                 }
5436                                             }
5437                                           else
5438                                             {
5439                                               /* 33222222222211111111110000000000
5440                                                  10987654321098765432109876543210
5441                                                  xxxxxxxxxx0011xxxxxxx1xx01111x1x
5442                                                  sqdmlsl.  */
5443                                               return 414;
5444                                             }
5445                                         }
5446                                     }
5447                                 }
5448                             }
5449                           else
5450                             {
5451                               if (((word >> 12) & 0x1) == 0)
5452                                 {
5453                                   if (((word >> 13) & 0x1) == 0)
5454                                     {
5455                                       if (((word >> 14) & 0x1) == 0)
5456                                         {
5457                                           if (((word >> 15) & 0x1) == 0)
5458                                             {
5459                                               if (((word >> 28) & 0x1) == 0)
5460                                                 {
5461                                                   if (((word >> 29) & 0x1) == 0)
5462                                                     {
5463                                                       /* 33222222222211111111110000000000
5464                                                          10987654321098765432109876543210
5465                                                          xxxxxxxxxx010000xxxxx1xx011100xx
5466                                                          rev64.  */
5467                                                       return 155;
5468                                                     }
5469                                                   else
5470                                                     {
5471                                                       /* 33222222222211111111110000000000
5472                                                          10987654321098765432109876543210
5473                                                          xxxxxxxxxx010000xxxxx1xx011101xx
5474                                                          rev32.  */
5475                                                       return 206;
5476                                                     }
5477                                                 }
5478                                               else
5479                                                 {
5480                                                   if (((word >> 30) & 0x1) == 0)
5481                                                     {
5482                                                       /* 33222222222211111111110000000000
5483                                                          10987654321098765432109876543210
5484                                                          xxxxxxxxxx010000xxxxx1xx01111x0x
5485                                                          fmul.  */
5486                                                       return 787;
5487                                                     }
5488                                                   else
5489                                                     {
5490                                                       /* 33222222222211111111110000000000
5491                                                          10987654321098765432109876543210
5492                                                          xxxxxxxxxx010000xxxxx1xx01111x1x
5493                                                          sha1h.  */
5494                                                       return 654;
5495                                                     }
5496                                                 }
5497                                             }
5498                                           else
5499                                             {
5500                                               if (((word >> 28) & 0x1) == 0)
5501                                                 {
5502                                                   if (((word >> 16) & 0x1) == 0)
5503                                                     {
5504                                                       if (((word >> 29) & 0x1) == 0)
5505                                                         {
5506                                                           /* 33222222222211111111110000000000
5507                                                              10987654321098765432109876543210
5508                                                              xxxxxxxxxx0100010xxxx1xx011100xx
5509                                                              cmgt.  */
5510                                                           return 163;
5511                                                         }
5512                                                       else
5513                                                         {
5514                                                           /* 33222222222211111111110000000000
5515                                                              10987654321098765432109876543210
5516                                                              xxxxxxxxxx0100010xxxx1xx011101xx
5517                                                              cmge.  */
5518                                                           return 212;
5519                                                         }
5520                                                     }
5521                                                   else
5522                                                     {
5523                                                       if (((word >> 19) & 0x1) == 0)
5524                                                         {
5525                                                           if (((word >> 23) & 0x1) == 0)
5526                                                             {
5527                                                               if (((word >> 29) & 0x1) == 0)
5528                                                                 {
5529                                                                   /* 33222222222211111111110000000000
5530                                                                      10987654321098765432109876543210
5531                                                                      xxxxxxxxxx0100011xx0x1x0011100xx
5532                                                                      frintn.  */
5533                                                                   return 175;
5534                                                                 }
5535                                                               else
5536                                                                 {
5537                                                                   /* 33222222222211111111110000000000
5538                                                                      10987654321098765432109876543210
5539                                                                      xxxxxxxxxx0100011xx0x1x0011101xx
5540                                                                      frinta.  */
5541                                                                   return 223;
5542                                                                 }
5543                                                             }
5544                                                           else
5545                                                             {
5546                                                               /* 33222222222211111111110000000000
5547                                                                  10987654321098765432109876543210
5548                                                                  xxxxxxxxxx0100011xx0x1x101110xxx
5549                                                                  frintp.  */
5550                                                               return 195;
5551                                                             }
5552                                                         }
5553                                                       else
5554                                                         {
5555                                                           if (((word >> 23) & 0x1) == 0)
5556                                                             {
5557                                                               if (((word >> 29) & 0x1) == 0)
5558                                                                 {
5559                                                                   /* 33222222222211111111110000000000
5560                                                                      10987654321098765432109876543210
5561                                                                      xxxxxxxxxx0100011xx1x1x0011100xx
5562                                                                      frintn.  */
5563                                                                   return 176;
5564                                                                 }
5565                                                               else
5566                                                                 {
5567                                                                   /* 33222222222211111111110000000000
5568                                                                      10987654321098765432109876543210
5569                                                                      xxxxxxxxxx0100011xx1x1x0011101xx
5570                                                                      frinta.  */
5571                                                                   return 224;
5572                                                                 }
5573                                                             }
5574                                                           else
5575                                                             {
5576                                                               /* 33222222222211111111110000000000
5577                                                                  10987654321098765432109876543210
5578                                                                  xxxxxxxxxx0100011xx1x1x101110xxx
5579                                                                  frintp.  */
5580                                                               return 196;
5581                                                             }
5582                                                         }
5583                                                     }
5584                                                 }
5585                                               else
5586                                                 {
5587                                                   if (((word >> 29) & 0x1) == 0)
5588                                                     {
5589                                                       if (((word >> 30) & 0x1) == 0)
5590                                                         {
5591                                                           /* 33222222222211111111110000000000
5592                                                              10987654321098765432109876543210
5593                                                              xxxxxxxxxx010001xxxxx1xx0111100x
5594                                                              fnmul.  */
5595                                                           return 803;
5596                                                         }
5597                                                       else
5598                                                         {
5599                                                           /* 33222222222211111111110000000000
5600                                                              10987654321098765432109876543210
5601                                                              xxxxxxxxxx010001xxxxx1xx0111101x
5602                                                              cmgt.  */
5603                                                           return 473;
5604                                                         }
5605                                                     }
5606                                                   else
5607                                                     {
5608                                                       /* 33222222222211111111110000000000
5609                                                          10987654321098765432109876543210
5610                                                          xxxxxxxxxx010001xxxxx1xx011111xx
5611                                                          cmge.  */
5612                                                       return 502;
5613                                                     }
5614                                                 }
5615                                             }
5616                                         }
5617                                       else
5618                                         {
5619                                           if (((word >> 15) & 0x1) == 0)
5620                                             {
5621                                               if (((word >> 28) & 0x1) == 0)
5622                                                 {
5623                                                   if (((word >> 16) & 0x1) == 0)
5624                                                     {
5625                                                       if (((word >> 19) & 0x1) == 0)
5626                                                         {
5627                                                           if (((word >> 29) & 0x1) == 0)
5628                                                             {
5629                                                               /* 33222222222211111111110000000000
5630                                                                  10987654321098765432109876543210
5631                                                                  xxxxxxxxxx0100100xx0x1xx011100xx
5632                                                                  cls.  */
5633                                                               return 159;
5634                                                             }
5635                                                           else
5636                                                             {
5637                                                               /* 33222222222211111111110000000000
5638                                                                  10987654321098765432109876543210
5639                                                                  xxxxxxxxxx0100100xx0x1xx011101xx
5640                                                                  clz.  */
5641                                                               return 209;
5642                                                             }
5643                                                         }
5644                                                       else
5645                                                         {
5646                                                           /* 33222222222211111111110000000000
5647                                                              10987654321098765432109876543210
5648                                                              xxxxxxxxxx0100100xx1x1xx01110xxx
5649                                                              aese.  */
5650                                                           return 650;
5651                                                         }
5652                                                     }
5653                                                   else
5654                                                     {
5655                                                       if (((word >> 29) & 0x1) == 0)
5656                                                         {
5657                                                           if (((word >> 30) & 0x1) == 0)
5658                                                             {
5659                                                               /* 33222222222211111111110000000000
5660                                                                  10987654321098765432109876543210
5661                                                                  xxxxxxxxxx0100101xxxx1xx0111000x
5662                                                                  sqxtn.  */
5663                                                               return 169;
5664                                                             }
5665                                                           else
5666                                                             {
5667                                                               /* 33222222222211111111110000000000
5668                                                                  10987654321098765432109876543210
5669                                                                  xxxxxxxxxx0100101xxxx1xx0111001x
5670                                                                  sqxtn2.  */
5671                                                               return 170;
5672                                                             }
5673                                                         }
5674                                                       else
5675                                                         {
5676                                                           if (((word >> 30) & 0x1) == 0)
5677                                                             {
5678                                                               /* 33222222222211111111110000000000
5679                                                                  10987654321098765432109876543210
5680                                                                  xxxxxxxxxx0100101xxxx1xx0111010x
5681                                                                  uqxtn.  */
5682                                                               return 219;
5683                                                             }
5684                                                           else
5685                                                             {
5686                                                               /* 33222222222211111111110000000000
5687                                                                  10987654321098765432109876543210
5688                                                                  xxxxxxxxxx0100101xxxx1xx0111011x
5689                                                                  uqxtn2.  */
5690                                                               return 220;
5691                                                             }
5692                                                         }
5693                                                     }
5694                                                 }
5695                                               else
5696                                                 {
5697                                                   if (((word >> 29) & 0x1) == 0)
5698                                                     {
5699                                                       if (((word >> 30) & 0x1) == 0)
5700                                                         {
5701                                                           /* 33222222222211111111110000000000
5702                                                              10987654321098765432109876543210
5703                                                              xxxxxxxxxx010010xxxxx1xx0111100x
5704                                                              fmax.  */
5705                                                           return 795;
5706                                                         }
5707                                                       else
5708                                                         {
5709                                                           /* 33222222222211111111110000000000
5710                                                              10987654321098765432109876543210
5711                                                              xxxxxxxxxx010010xxxxx1xx0111101x
5712                                                              sqxtn.  */
5713                                                           return 477;
5714                                                         }
5715                                                     }
5716                                                   else
5717                                                     {
5718                                                       /* 33222222222211111111110000000000
5719                                                          10987654321098765432109876543210
5720                                                          xxxxxxxxxx010010xxxxx1xx011111xx
5721                                                          uqxtn.  */
5722                                                       return 506;
5723                                                     }
5724                                                 }
5725                                             }
5726                                           else
5727                                             {
5728                                               if (((word >> 16) & 0x1) == 0)
5729                                                 {
5730                                                   if (((word >> 19) & 0x1) == 0)
5731                                                     {
5732                                                       if (((word >> 20) & 0x1) == 0)
5733                                                         {
5734                                                           if (((word >> 28) & 0x1) == 0)
5735                                                             {
5736                                                               if (((word >> 29) & 0x1) == 0)
5737                                                                 {
5738                                                                   /* 33222222222211111111110000000000
5739                                                                      10987654321098765432109876543210
5740                                                                      xxxxxxxxxx0100110xx001xx011100xx
5741                                                                      fcmgt.  */
5742                                                                   return 187;
5743                                                                 }
5744                                                               else
5745                                                                 {
5746                                                                   /* 33222222222211111111110000000000
5747                                                                      10987654321098765432109876543210
5748                                                                      xxxxxxxxxx0100110xx001xx011101xx
5749                                                                      fcmge.  */
5750                                                                   return 238;
5751                                                                 }
5752                                                             }
5753                                                           else
5754                                                             {
5755                                                               if (((word >> 29) & 0x1) == 0)
5756                                                                 {
5757                                                                   /* 33222222222211111111110000000000
5758                                                                      10987654321098765432109876543210
5759                                                                      xxxxxxxxxx0100110xx001xx011110xx
5760                                                                      fcmgt.  */
5761                                                                   return 486;
5762                                                                 }
5763                                                               else
5764                                                                 {
5765                                                                   /* 33222222222211111111110000000000
5766                                                                      10987654321098765432109876543210
5767                                                                      xxxxxxxxxx0100110xx001xx011111xx
5768                                                                      fcmge.  */
5769                                                                   return 516;
5770                                                                 }
5771                                                             }
5772                                                         }
5773                                                       else
5774                                                         {
5775                                                           if (((word >> 23) & 0x1) == 0)
5776                                                             {
5777                                                               if (((word >> 28) & 0x1) == 0)
5778                                                                 {
5779                                                                   if (((word >> 29) & 0x1) == 0)
5780                                                                     {
5781                                                                       /* 33222222222211111111110000000000
5782                                                                          10987654321098765432109876543210
5783                                                                          xxxxxxxxxx0100110xx011x0011100xx
5784                                                                          fmaxnmv.  */
5785                                                                       return 35;
5786                                                                     }
5787                                                                   else
5788                                                                     {
5789                                                                       /* 33222222222211111111110000000000
5790                                                                          10987654321098765432109876543210
5791                                                                          xxxxxxxxxx0100110xx011x0011101xx
5792                                                                          fmaxnmv.  */
5793                                                                       return 34;
5794                                                                     }
5795                                                                 }
5796                                                               else
5797                                                                 {
5798                                                                   if (((word >> 29) & 0x1) == 0)
5799                                                                     {
5800                                                                       /* 33222222222211111111110000000000
5801                                                                          10987654321098765432109876543210
5802                                                                          xxxxxxxxxx0100110xx011x0011110xx
5803                                                                          fmaxnmp.  */
5804                                                                       return 530;
5805                                                                     }
5806                                                                   else
5807                                                                     {
5808                                                                       /* 33222222222211111111110000000000
5809                                                                          10987654321098765432109876543210
5810                                                                          xxxxxxxxxx0100110xx011x0011111xx
5811                                                                          fmaxnmp.  */
5812                                                                       return 529;
5813                                                                     }
5814                                                                 }
5815                                                             }
5816                                                           else
5817                                                             {
5818                                                               if (((word >> 28) & 0x1) == 0)
5819                                                                 {
5820                                                                   if (((word >> 29) & 0x1) == 0)
5821                                                                     {
5822                                                                       /* 33222222222211111111110000000000
5823                                                                          10987654321098765432109876543210
5824                                                                          xxxxxxxxxx0100110xx011x1011100xx
5825                                                                          fminnmv.  */
5826                                                                       return 39;
5827                                                                     }
5828                                                                   else
5829                                                                     {
5830                                                                       /* 33222222222211111111110000000000
5831                                                                          10987654321098765432109876543210
5832                                                                          xxxxxxxxxx0100110xx011x1011101xx
5833                                                                          fminnmv.  */
5834                                                                       return 38;
5835                                                                     }
5836                                                                 }
5837                                                               else
5838                                                                 {
5839                                                                   if (((word >> 29) & 0x1) == 0)
5840                                                                     {
5841                                                                       /* 33222222222211111111110000000000
5842                                                                          10987654321098765432109876543210
5843                                                                          xxxxxxxxxx0100110xx011x1011110xx
5844                                                                          fminnmp.  */
5845                                                                       return 536;
5846                                                                     }
5847                                                                   else
5848                                                                     {
5849                                                                       /* 33222222222211111111110000000000
5850                                                                          10987654321098765432109876543210
5851                                                                          xxxxxxxxxx0100110xx011x1011111xx
5852                                                                          fminnmp.  */
5853                                                                       return 535;
5854                                                                     }
5855                                                                 }
5856                                                             }
5857                                                         }
5858                                                     }
5859                                                   else
5860                                                     {
5861                                                       if (((word >> 28) & 0x1) == 0)
5862                                                         {
5863                                                           if (((word >> 29) & 0x1) == 0)
5864                                                             {
5865                                                               /* 33222222222211111111110000000000
5866                                                                  10987654321098765432109876543210
5867                                                                  xxxxxxxxxx0100110xx1x1xx011100xx
5868                                                                  fcmgt.  */
5869                                                               return 188;
5870                                                             }
5871                                                           else
5872                                                             {
5873                                                               /* 33222222222211111111110000000000
5874                                                                  10987654321098765432109876543210
5875                                                                  xxxxxxxxxx0100110xx1x1xx011101xx
5876                                                                  fcmge.  */
5877                                                               return 239;
5878                                                             }
5879                                                         }
5880                                                       else
5881                                                         {
5882                                                           if (((word >> 29) & 0x1) == 0)
5883                                                             {
5884                                                               /* 33222222222211111111110000000000
5885                                                                  10987654321098765432109876543210
5886                                                                  xxxxxxxxxx0100110xx1x1xx011110xx
5887                                                                  fcmgt.  */
5888                                                               return 487;
5889                                                             }
5890                                                           else
5891                                                             {
5892                                                               /* 33222222222211111111110000000000
5893                                                                  10987654321098765432109876543210
5894                                                                  xxxxxxxxxx0100110xx1x1xx011111xx
5895                                                                  fcmge.  */
5896                                                               return 517;
5897                                                             }
5898                                                         }
5899                                                     }
5900                                                 }
5901                                               else
5902                                                 {
5903                                                   if (((word >> 19) & 0x1) == 0)
5904                                                     {
5905                                                       if (((word >> 23) & 0x1) == 0)
5906                                                         {
5907                                                           if (((word >> 28) & 0x1) == 0)
5908                                                             {
5909                                                               if (((word >> 29) & 0x1) == 0)
5910                                                                 {
5911                                                                   /* 33222222222211111111110000000000
5912                                                                      10987654321098765432109876543210
5913                                                                      xxxxxxxxxx0100111xx0x1x0011100xx
5914                                                                      fcvtas.  */
5915                                                                   return 183;
5916                                                                 }
5917                                                               else
5918                                                                 {
5919                                                                   /* 33222222222211111111110000000000
5920                                                                      10987654321098765432109876543210
5921                                                                      xxxxxxxxxx0100111xx0x1x0011101xx
5922                                                                      fcvtau.  */
5923                                                                   return 231;
5924                                                                 }
5925                                                             }
5926                                                           else
5927                                                             {
5928                                                               if (((word >> 29) & 0x1) == 0)
5929                                                                 {
5930                                                                   /* 33222222222211111111110000000000
5931                                                                      10987654321098765432109876543210
5932                                                                      xxxxxxxxxx0100111xx0x1x0011110xx
5933                                                                      fcvtas.  */
5934                                                                   return 482;
5935                                                                 }
5936                                                               else
5937                                                                 {
5938                                                                   /* 33222222222211111111110000000000
5939                                                                      10987654321098765432109876543210
5940                                                                      xxxxxxxxxx0100111xx0x1x0011111xx
5941                                                                      fcvtau.  */
5942                                                                   return 512;
5943                                                                 }
5944                                                             }
5945                                                         }
5946                                                       else
5947                                                         {
5948                                                           if (((word >> 29) & 0x1) == 0)
5949                                                             {
5950                                                               /* 33222222222211111111110000000000
5951                                                                  10987654321098765432109876543210
5952                                                                  xxxxxxxxxx0100111xx0x1x10111x0xx
5953                                                                  urecpe.  */
5954                                                               return 203;
5955                                                             }
5956                                                           else
5957                                                             {
5958                                                               /* 33222222222211111111110000000000
5959                                                                  10987654321098765432109876543210
5960                                                                  xxxxxxxxxx0100111xx0x1x10111x1xx
5961                                                                  ursqrte.  */
5962                                                               return 250;
5963                                                             }
5964                                                         }
5965                                                     }
5966                                                   else
5967                                                     {
5968                                                       if (((word >> 28) & 0x1) == 0)
5969                                                         {
5970                                                           if (((word >> 29) & 0x1) == 0)
5971                                                             {
5972                                                               /* 33222222222211111111110000000000
5973                                                                  10987654321098765432109876543210
5974                                                                  xxxxxxxxxx0100111xx1x1xx011100xx
5975                                                                  fcvtas.  */
5976                                                               return 184;
5977                                                             }
5978                                                           else
5979                                                             {
5980                                                               /* 33222222222211111111110000000000
5981                                                                  10987654321098765432109876543210
5982                                                                  xxxxxxxxxx0100111xx1x1xx011101xx
5983                                                                  fcvtau.  */
5984                                                               return 232;
5985                                                             }
5986                                                         }
5987                                                       else
5988                                                         {
5989                                                           if (((word >> 29) & 0x1) == 0)
5990                                                             {
5991                                                               /* 33222222222211111111110000000000
5992                                                                  10987654321098765432109876543210
5993                                                                  xxxxxxxxxx0100111xx1x1xx011110xx
5994                                                                  fcvtas.  */
5995                                                               return 483;
5996                                                             }
5997                                                           else
5998                                                             {
5999                                                               /* 33222222222211111111110000000000
6000                                                                  10987654321098765432109876543210
6001                                                                  xxxxxxxxxx0100111xx1x1xx011111xx
6002                                                                  fcvtau.  */
6003                                                               return 513;
6004                                                             }
6005                                                         }
6006                                                     }
6007                                                 }
6008                                             }
6009                                         }
6010                                     }
6011                                   else
6012                                     {
6013                                       if (((word >> 14) & 0x1) == 0)
6014                                         {
6015                                           if (((word >> 15) & 0x1) == 0)
6016                                             {
6017                                               if (((word >> 28) & 0x1) == 0)
6018                                                 {
6019                                                   if (((word >> 16) & 0x1) == 0)
6020                                                     {
6021                                                       if (((word >> 29) & 0x1) == 0)
6022                                                         {
6023                                                           /* 33222222222211111111110000000000
6024                                                              10987654321098765432109876543210
6025                                                              xxxxxxxxxx0101000xxxx1xx011100xx
6026                                                              saddlp.  */
6027                                                           return 157;
6028                                                         }
6029                                                       else
6030                                                         {
6031                                                           /* 33222222222211111111110000000000
6032                                                              10987654321098765432109876543210
6033                                                              xxxxxxxxxx0101000xxxx1xx011101xx
6034                                                              uaddlp.  */
6035                                                           return 207;
6036                                                         }
6037                                                     }
6038                                                   else
6039                                                     {
6040                                                       if (((word >> 29) & 0x1) == 0)
6041                                                         {
6042                                                           if (((word >> 30) & 0x1) == 0)
6043                                                             {
6044                                                               /* 33222222222211111111110000000000
6045                                                                  10987654321098765432109876543210
6046                                                                  xxxxxxxxxx0101001xxxx1xx0111000x
6047                                                                  xtn.  */
6048                                                               return 167;
6049                                                             }
6050                                                           else
6051                                                             {
6052                                                               /* 33222222222211111111110000000000
6053                                                                  10987654321098765432109876543210
6054                                                                  xxxxxxxxxx0101001xxxx1xx0111001x
6055                                                                  xtn2.  */
6056                                                               return 168;
6057                                                             }
6058                                                         }
6059                                                       else
6060                                                         {
6061                                                           if (((word >> 30) & 0x1) == 0)
6062                                                             {
6063                                                               /* 33222222222211111111110000000000
6064                                                                  10987654321098765432109876543210
6065                                                                  xxxxxxxxxx0101001xxxx1xx0111010x
6066                                                                  sqxtun.  */
6067                                                               return 215;
6068                                                             }
6069                                                           else
6070                                                             {
6071                                                               /* 33222222222211111111110000000000
6072                                                                  10987654321098765432109876543210
6073                                                                  xxxxxxxxxx0101001xxxx1xx0111011x
6074                                                                  sqxtun2.  */
6075                                                               return 216;
6076                                                             }
6077                                                         }
6078                                                     }
6079                                                 }
6080                                               else
6081                                                 {
6082                                                   if (((word >> 29) & 0x1) == 0)
6083                                                     {
6084                                                       if (((word >> 30) & 0x1) == 0)
6085                                                         {
6086                                                           /* 33222222222211111111110000000000
6087                                                              10987654321098765432109876543210
6088                                                              xxxxxxxxxx010100xxxxx1xx0111100x
6089                                                              fadd.  */
6090                                                           return 791;
6091                                                         }
6092                                                       else
6093                                                         {
6094                                                           /* 33222222222211111111110000000000
6095                                                              10987654321098765432109876543210
6096                                                              xxxxxxxxxx010100xxxxx1xx0111101x
6097                                                              sha256su0.  */
6098                                                           return 656;
6099                                                         }
6100                                                     }
6101                                                   else
6102                                                     {
6103                                                       /* 33222222222211111111110000000000
6104                                                          10987654321098765432109876543210
6105                                                          xxxxxxxxxx010100xxxxx1xx011111xx
6106                                                          sqxtun.  */
6107                                                       return 505;
6108                                                     }
6109                                                 }
6110                                             }
6111                                           else
6112                                             {
6113                                               if (((word >> 16) & 0x1) == 0)
6114                                                 {
6115                                                   if (((word >> 20) & 0x1) == 0)
6116                                                     {
6117                                                       if (((word >> 28) & 0x1) == 0)
6118                                                         {
6119                                                           /* 33222222222211111111110000000000
6120                                                              10987654321098765432109876543210
6121                                                              xxxxxxxxxx0101010xxx01xx01110xxx
6122                                                              cmlt.  */
6123                                                           return 165;
6124                                                         }
6125                                                       else
6126                                                         {
6127                                                           /* 33222222222211111111110000000000
6128                                                              10987654321098765432109876543210
6129                                                              xxxxxxxxxx0101010xxx01xx01111xxx
6130                                                              cmlt.  */
6131                                                           return 475;
6132                                                         }
6133                                                     }
6134                                                   else
6135                                                     {
6136                                                       if (((word >> 29) & 0x1) == 0)
6137                                                         {
6138                                                           /* 33222222222211111111110000000000
6139                                                              10987654321098765432109876543210
6140                                                              xxxxxxxxxx0101010xxx11xx0111x0xx
6141                                                              smaxv.  */
6142                                                           return 28;
6143                                                         }
6144                                                       else
6145                                                         {
6146                                                           /* 33222222222211111111110000000000
6147                                                              10987654321098765432109876543210
6148                                                              xxxxxxxxxx0101010xxx11xx0111x1xx
6149                                                              umaxv.  */
6150                                                           return 32;
6151                                                         }
6152                                                     }
6153                                                 }
6154                                               else
6155                                                 {
6156                                                   if (((word >> 19) & 0x1) == 0)
6157                                                     {
6158                                                       if (((word >> 20) & 0x1) == 0)
6159                                                         {
6160                                                           if (((word >> 23) & 0x1) == 0)
6161                                                             {
6162                                                               if (((word >> 28) & 0x1) == 0)
6163                                                                 {
6164                                                                   if (((word >> 29) & 0x1) == 0)
6165                                                                     {
6166                                                                       /* 33222222222211111111110000000000
6167                                                                          10987654321098765432109876543210
6168                                                                          xxxxxxxxxx0101011xx001x0011100xx
6169                                                                          fcvtns.  */
6170                                                                       return 179;
6171                                                                     }
6172                                                                   else
6173                                                                     {
6174                                                                       /* 33222222222211111111110000000000
6175                                                                          10987654321098765432109876543210
6176                                                                          xxxxxxxxxx0101011xx001x0011101xx
6177                                                                          fcvtnu.  */
6178                                                                       return 227;
6179                                                                     }
6180                                                                 }
6181                                                               else
6182                                                                 {
6183                                                                   if (((word >> 29) & 0x1) == 0)
6184                                                                     {
6185                                                                       /* 33222222222211111111110000000000
6186                                                                          10987654321098765432109876543210
6187                                                                          xxxxxxxxxx0101011xx001x0011110xx
6188                                                                          fcvtns.  */
6189                                                                       return 478;
6190                                                                     }
6191                                                                   else
6192                                                                     {
6193                                                                       /* 33222222222211111111110000000000
6194                                                                          10987654321098765432109876543210
6195                                                                          xxxxxxxxxx0101011xx001x0011111xx
6196                                                                          fcvtnu.  */
6197                                                                       return 508;
6198                                                                     }
6199                                                                 }
6200                                                             }
6201                                                           else
6202                                                             {
6203                                                               if (((word >> 28) & 0x1) == 0)
6204                                                                 {
6205                                                                   if (((word >> 29) & 0x1) == 0)
6206                                                                     {
6207                                                                       /* 33222222222211111111110000000000
6208                                                                          10987654321098765432109876543210
6209                                                                          xxxxxxxxxx0101011xx001x1011100xx
6210                                                                          fcvtps.  */
6211                                                                       return 199;
6212                                                                     }
6213                                                                   else
6214                                                                     {
6215                                                                       /* 33222222222211111111110000000000
6216                                                                          10987654321098765432109876543210
6217                                                                          xxxxxxxxxx0101011xx001x1011101xx
6218                                                                          fcvtpu.  */
6219                                                                       return 246;
6220                                                                     }
6221                                                                 }
6222                                                               else
6223                                                                 {
6224                                                                   if (((word >> 29) & 0x1) == 0)
6225                                                                     {
6226                                                                       /* 33222222222211111111110000000000
6227                                                                          10987654321098765432109876543210
6228                                                                          xxxxxxxxxx0101011xx001x1011110xx
6229                                                                          fcvtps.  */
6230                                                                       return 492;
6231                                                                     }
6232                                                                   else
6233                                                                     {
6234                                                                       /* 33222222222211111111110000000000
6235                                                                          10987654321098765432109876543210
6236                                                                          xxxxxxxxxx0101011xx001x1011111xx
6237                                                                          fcvtpu.  */
6238                                                                       return 520;
6239                                                                     }
6240                                                                 }
6241                                                             }
6242                                                         }
6243                                                       else
6244                                                         {
6245                                                           if (((word >> 29) & 0x1) == 0)
6246                                                             {
6247                                                               /* 33222222222211111111110000000000
6248                                                                  10987654321098765432109876543210
6249                                                                  xxxxxxxxxx0101011xx011xx0111x0xx
6250                                                                  sminv.  */
6251                                                               return 29;
6252                                                             }
6253                                                           else
6254                                                             {
6255                                                               /* 33222222222211111111110000000000
6256                                                                  10987654321098765432109876543210
6257                                                                  xxxxxxxxxx0101011xx011xx0111x1xx
6258                                                                  uminv.  */
6259                                                               return 33;
6260                                                             }
6261                                                         }
6262                                                     }
6263                                                   else
6264                                                     {
6265                                                       if (((word >> 23) & 0x1) == 0)
6266                                                         {
6267                                                           if (((word >> 28) & 0x1) == 0)
6268                                                             {
6269                                                               if (((word >> 29) & 0x1) == 0)
6270                                                                 {
6271                                                                   /* 33222222222211111111110000000000
6272                                                                      10987654321098765432109876543210
6273                                                                      xxxxxxxxxx0101011xx1x1x0011100xx
6274                                                                      fcvtns.  */
6275                                                                   return 180;
6276                                                                 }
6277                                                               else
6278                                                                 {
6279                                                                   /* 33222222222211111111110000000000
6280                                                                      10987654321098765432109876543210
6281                                                                      xxxxxxxxxx0101011xx1x1x0011101xx
6282                                                                      fcvtnu.  */
6283                                                                   return 228;
6284                                                                 }
6285                                                             }
6286                                                           else
6287                                                             {
6288                                                               if (((word >> 29) & 0x1) == 0)
6289                                                                 {
6290                                                                   /* 33222222222211111111110000000000
6291                                                                      10987654321098765432109876543210
6292                                                                      xxxxxxxxxx0101011xx1x1x0011110xx
6293                                                                      fcvtns.  */
6294                                                                   return 479;
6295                                                                 }
6296                                                               else
6297                                                                 {
6298                                                                   /* 33222222222211111111110000000000
6299                                                                      10987654321098765432109876543210
6300                                                                      xxxxxxxxxx0101011xx1x1x0011111xx
6301                                                                      fcvtnu.  */
6302                                                                   return 509;
6303                                                                 }
6304                                                             }
6305                                                         }
6306                                                       else
6307                                                         {
6308                                                           if (((word >> 28) & 0x1) == 0)
6309                                                             {
6310                                                               if (((word >> 29) & 0x1) == 0)
6311                                                                 {
6312                                                                   /* 33222222222211111111110000000000
6313                                                                      10987654321098765432109876543210
6314                                                                      xxxxxxxxxx0101011xx1x1x1011100xx
6315                                                                      fcvtps.  */
6316                                                                   return 200;
6317                                                                 }
6318                                                               else
6319                                                                 {
6320                                                                   /* 33222222222211111111110000000000
6321                                                                      10987654321098765432109876543210
6322                                                                      xxxxxxxxxx0101011xx1x1x1011101xx
6323                                                                      fcvtpu.  */
6324                                                                   return 247;
6325                                                                 }
6326                                                             }
6327                                                           else
6328                                                             {
6329                                                               if (((word >> 29) & 0x1) == 0)
6330                                                                 {
6331                                                                   /* 33222222222211111111110000000000
6332                                                                      10987654321098765432109876543210
6333                                                                      xxxxxxxxxx0101011xx1x1x1011110xx
6334                                                                      fcvtps.  */
6335                                                                   return 493;
6336                                                                 }
6337                                                               else
6338                                                                 {
6339                                                                   /* 33222222222211111111110000000000
6340                                                                      10987654321098765432109876543210
6341                                                                      xxxxxxxxxx0101011xx1x1x1011111xx
6342                                                                      fcvtpu.  */
6343                                                                   return 521;
6344                                                                 }
6345                                                             }
6346                                                         }
6347                                                     }
6348                                                 }
6349                                             }
6350                                         }
6351                                       else
6352                                         {
6353                                           if (((word >> 15) & 0x1) == 0)
6354                                             {
6355                                               if (((word >> 28) & 0x1) == 0)
6356                                                 {
6357                                                   if (((word >> 16) & 0x1) == 0)
6358                                                     {
6359                                                       if (((word >> 19) & 0x1) == 0)
6360                                                         {
6361                                                           if (((word >> 29) & 0x1) == 0)
6362                                                             {
6363                                                               /* 33222222222211111111110000000000
6364                                                                  10987654321098765432109876543210
6365                                                                  xxxxxxxxxx0101100xx0x1xx011100xx
6366                                                                  sadalp.  */
6367                                                               return 161;
6368                                                             }
6369                                                           else
6370                                                             {
6371                                                               /* 33222222222211111111110000000000
6372                                                                  10987654321098765432109876543210
6373                                                                  xxxxxxxxxx0101100xx0x1xx011101xx
6374                                                                  uadalp.  */
6375                                                               return 210;
6376                                                             }
6377                                                         }
6378                                                       else
6379                                                         {
6380                                                           /* 33222222222211111111110000000000
6381                                                              10987654321098765432109876543210
6382                                                              xxxxxxxxxx0101100xx1x1xx01110xxx
6383                                                              aesmc.  */
6384                                                           return 652;
6385                                                         }
6386                                                     }
6387                                                   else
6388                                                     {
6389                                                       if (((word >> 29) & 0x1) == 0)
6390                                                         {
6391                                                           if (((word >> 30) & 0x1) == 0)
6392                                                             {
6393                                                               /* 33222222222211111111110000000000
6394                                                                  10987654321098765432109876543210
6395                                                                  xxxxxxxxxx0101101xxxx1xx0111000x
6396                                                                  fcvtn.  */
6397                                                               return 171;
6398                                                             }
6399                                                           else
6400                                                             {
6401                                                               /* 33222222222211111111110000000000
6402                                                                  10987654321098765432109876543210
6403                                                                  xxxxxxxxxx0101101xxxx1xx0111001x
6404                                                                  fcvtn2.  */
6405                                                               return 172;
6406                                                             }
6407                                                         }
6408                                                       else
6409                                                         {
6410                                                           if (((word >> 30) & 0x1) == 0)
6411                                                             {
6412                                                               /* 33222222222211111111110000000000
6413                                                                  10987654321098765432109876543210
6414                                                                  xxxxxxxxxx0101101xxxx1xx0111010x
6415                                                                  fcvtxn.  */
6416                                                               return 221;
6417                                                             }
6418                                                           else
6419                                                             {
6420                                                               /* 33222222222211111111110000000000
6421                                                                  10987654321098765432109876543210
6422                                                                  xxxxxxxxxx0101101xxxx1xx0111011x
6423                                                                  fcvtxn2.  */
6424                                                               return 222;
6425                                                             }
6426                                                         }
6427                                                     }
6428                                                 }
6429                                               else
6430                                                 {
6431                                                   if (((word >> 29) & 0x1) == 0)
6432                                                     {
6433                                                       /* 33222222222211111111110000000000
6434                                                          10987654321098765432109876543210
6435                                                          xxxxxxxxxx010110xxxxx1xx011110xx
6436                                                          fmaxnm.  */
6437                                                       return 799;
6438                                                     }
6439                                                   else
6440                                                     {
6441                                                       /* 33222222222211111111110000000000
6442                                                          10987654321098765432109876543210
6443                                                          xxxxxxxxxx010110xxxxx1xx011111xx
6444                                                          fcvtxn.  */
6445                                                       return 507;
6446                                                     }
6447                                                 }
6448                                             }
6449                                           else
6450                                             {
6451                                               if (((word >> 19) & 0x1) == 0)
6452                                                 {
6453                                                   if (((word >> 28) & 0x1) == 0)
6454                                                     {
6455                                                       /* 33222222222211111111110000000000
6456                                                          10987654321098765432109876543210
6457                                                          xxxxxxxxxx010111xxx0x1xx01110xxx
6458                                                          fcmlt.  */
6459                                                       return 191;
6460                                                     }
6461                                                   else
6462                                                     {
6463                                                       /* 33222222222211111111110000000000
6464                                                          10987654321098765432109876543210
6465                                                          xxxxxxxxxx010111xxx0x1xx01111xxx
6466                                                          fcmlt.  */
6467                                                       return 490;
6468                                                     }
6469                                                 }
6470                                               else
6471                                                 {
6472                                                   if (((word >> 28) & 0x1) == 0)
6473                                                     {
6474                                                       /* 33222222222211111111110000000000
6475                                                          10987654321098765432109876543210
6476                                                          xxxxxxxxxx010111xxx1x1xx01110xxx
6477                                                          fcmlt.  */
6478                                                       return 192;
6479                                                     }
6480                                                   else
6481                                                     {
6482                                                       /* 33222222222211111111110000000000
6483                                                          10987654321098765432109876543210
6484                                                          xxxxxxxxxx010111xxx1x1xx01111xxx
6485                                                          fcmlt.  */
6486                                                       return 491;
6487                                                     }
6488                                                 }
6489                                             }
6490                                         }
6491                                     }
6492                                 }
6493                               else
6494                                 {
6495                                   if (((word >> 13) & 0x1) == 0)
6496                                     {
6497                                       if (((word >> 14) & 0x1) == 0)
6498                                         {
6499                                           if (((word >> 15) & 0x1) == 0)
6500                                             {
6501                                               if (((word >> 28) & 0x1) == 0)
6502                                                 {
6503                                                   /* 33222222222211111111110000000000
6504                                                      10987654321098765432109876543210
6505                                                      xxxxxxxxxx011000xxxxx1xx01110xxx
6506                                                      rev16.  */
6507                                                   return 156;
6508                                                 }
6509                                               else
6510                                                 {
6511                                                   if (((word >> 30) & 0x1) == 0)
6512                                                     {
6513                                                       /* 33222222222211111111110000000000
6514                                                          10987654321098765432109876543210
6515                                                          xxxxxxxxxx011000xxxxx1xx01111x0x
6516                                                          fdiv.  */
6517                                                       return 789;
6518                                                     }
6519                                                   else
6520                                                     {
6521                                                       /* 33222222222211111111110000000000
6522                                                          10987654321098765432109876543210
6523                                                          xxxxxxxxxx011000xxxxx1xx01111x1x
6524                                                          sha1su1.  */
6525                                                       return 655;
6526                                                     }
6527                                                 }
6528                                             }
6529                                           else
6530                                             {
6531                                               if (((word >> 16) & 0x1) == 0)
6532                                                 {
6533                                                   if (((word >> 28) & 0x1) == 0)
6534                                                     {
6535                                                       if (((word >> 29) & 0x1) == 0)
6536                                                         {
6537                                                           /* 33222222222211111111110000000000
6538                                                              10987654321098765432109876543210
6539                                                              xxxxxxxxxx0110010xxxx1xx011100xx
6540                                                              cmeq.  */
6541                                                           return 164;
6542                                                         }
6543                                                       else
6544                                                         {
6545                                                           /* 33222222222211111111110000000000
6546                                                              10987654321098765432109876543210
6547                                                              xxxxxxxxxx0110010xxxx1xx011101xx
6548                                                              cmle.  */
6549                                                           return 213;
6550                                                         }
6551                                                     }
6552                                                   else
6553                                                     {
6554                                                       if (((word >> 29) & 0x1) == 0)
6555                                                         {
6556                                                           /* 33222222222211111111110000000000
6557                                                              10987654321098765432109876543210
6558                                                              xxxxxxxxxx0110010xxxx1xx011110xx
6559                                                              cmeq.  */
6560                                                           return 474;
6561                                                         }
6562                                                       else
6563                                                         {
6564                                                           /* 33222222222211111111110000000000
6565                                                              10987654321098765432109876543210
6566                                                              xxxxxxxxxx0110010xxxx1xx011111xx
6567                                                              cmle.  */
6568                                                           return 503;
6569                                                         }
6570                                                     }
6571                                                 }
6572                                               else
6573                                                 {
6574                                                   if (((word >> 19) & 0x1) == 0)
6575                                                     {
6576                                                       if (((word >> 23) & 0x1) == 0)
6577                                                         {
6578                                                           if (((word >> 29) & 0x1) == 0)
6579                                                             {
6580                                                               /* 33222222222211111111110000000000
6581                                                                  10987654321098765432109876543210
6582                                                                  xxxxxxxxxx0110011xx0x1x00111x0xx
6583                                                                  frintm.  */
6584                                                               return 177;
6585                                                             }
6586                                                           else
6587                                                             {
6588                                                               /* 33222222222211111111110000000000
6589                                                                  10987654321098765432109876543210
6590                                                                  xxxxxxxxxx0110011xx0x1x00111x1xx
6591                                                                  frintx.  */
6592                                                               return 225;
6593                                                             }
6594                                                         }
6595                                                       else
6596                                                         {
6597                                                           if (((word >> 29) & 0x1) == 0)
6598                                                             {
6599                                                               /* 33222222222211111111110000000000
6600                                                                  10987654321098765432109876543210
6601                                                                  xxxxxxxxxx0110011xx0x1x10111x0xx
6602                                                                  frintz.  */
6603                                                               return 197;
6604                                                             }
6605                                                           else
6606                                                             {
6607                                                               /* 33222222222211111111110000000000
6608                                                                  10987654321098765432109876543210
6609                                                                  xxxxxxxxxx0110011xx0x1x10111x1xx
6610                                                                  frinti.  */
6611                                                               return 244;
6612                                                             }
6613                                                         }
6614                                                     }
6615                                                   else
6616                                                     {
6617                                                       if (((word >> 23) & 0x1) == 0)
6618                                                         {
6619                                                           if (((word >> 29) & 0x1) == 0)
6620                                                             {
6621                                                               /* 33222222222211111111110000000000
6622                                                                  10987654321098765432109876543210
6623                                                                  xxxxxxxxxx0110011xx1x1x00111x0xx
6624                                                                  frintm.  */
6625                                                               return 178;
6626                                                             }
6627                                                           else
6628                                                             {
6629                                                               /* 33222222222211111111110000000000
6630                                                                  10987654321098765432109876543210
6631                                                                  xxxxxxxxxx0110011xx1x1x00111x1xx
6632                                                                  frintx.  */
6633                                                               return 226;
6634                                                             }
6635                                                         }
6636                                                       else
6637                                                         {
6638                                                           if (((word >> 29) & 0x1) == 0)
6639                                                             {
6640                                                               /* 33222222222211111111110000000000
6641                                                                  10987654321098765432109876543210
6642                                                                  xxxxxxxxxx0110011xx1x1x10111x0xx
6643                                                                  frintz.  */
6644                                                               return 198;
6645                                                             }
6646                                                           else
6647                                                             {
6648                                                               /* 33222222222211111111110000000000
6649                                                                  10987654321098765432109876543210
6650                                                                  xxxxxxxxxx0110011xx1x1x10111x1xx
6651                                                                  frinti.  */
6652                                                               return 245;
6653                                                             }
6654                                                         }
6655                                                     }
6656                                                 }
6657                                             }
6658                                         }
6659                                       else
6660                                         {
6661                                           if (((word >> 15) & 0x1) == 0)
6662                                             {
6663                                               if (((word >> 28) & 0x1) == 0)
6664                                                 {
6665                                                   if (((word >> 19) & 0x1) == 0)
6666                                                     {
6667                                                       if (((word >> 29) & 0x1) == 0)
6668                                                         {
6669                                                           /* 33222222222211111111110000000000
6670                                                              10987654321098765432109876543210
6671                                                              xxxxxxxxxx011010xxx0x1xx011100xx
6672                                                              cnt.  */
6673                                                           return 160;
6674                                                         }
6675                                                       else
6676                                                         {
6677                                                           if (((word >> 22) & 0x1) == 0)
6678                                                             {
6679                                                               /* 33222222222211111111110000000000
6680                                                                  10987654321098765432109876543210
6681                                                                  xxxxxxxxxx011010xxx0x10x011101xx
6682                                                                  not.  */
6683                                                               return 235;
6684                                                             }
6685                                                           else
6686                                                             {
6687                                                               /* 33222222222211111111110000000000
6688                                                                  10987654321098765432109876543210
6689                                                                  xxxxxxxxxx011010xxx0x11x011101xx
6690                                                                  rbit.  */
6691                                                               return 237;
6692                                                             }
6693                                                         }
6694                                                     }
6695                                                   else
6696                                                     {
6697                                                       /* 33222222222211111111110000000000
6698                                                          10987654321098765432109876543210
6699                                                          xxxxxxxxxx011010xxx1x1xx01110xxx
6700                                                          aesd.  */
6701                                                       return 651;
6702                                                     }
6703                                                 }
6704                                               else
6705                                                 {
6706                                                   /* 33222222222211111111110000000000
6707                                                      10987654321098765432109876543210
6708                                                      xxxxxxxxxx011010xxxxx1xx01111xxx
6709                                                      fmin.  */
6710                                                   return 797;
6711                                                 }
6712                                             }
6713                                           else
6714                                             {
6715                                               if (((word >> 16) & 0x1) == 0)
6716                                                 {
6717                                                   if (((word >> 19) & 0x1) == 0)
6718                                                     {
6719                                                       if (((word >> 20) & 0x1) == 0)
6720                                                         {
6721                                                           if (((word >> 28) & 0x1) == 0)
6722                                                             {
6723                                                               if (((word >> 29) & 0x1) == 0)
6724                                                                 {
6725                                                                   /* 33222222222211111111110000000000
6726                                                                      10987654321098765432109876543210
6727                                                                      xxxxxxxxxx0110110xx001xx011100xx
6728                                                                      fcmeq.  */
6729                                                                   return 189;
6730                                                                 }
6731                                                               else
6732                                                                 {
6733                                                                   /* 33222222222211111111110000000000
6734                                                                      10987654321098765432109876543210
6735                                                                      xxxxxxxxxx0110110xx001xx011101xx
6736                                                                      fcmle.  */
6737                                                                   return 240;
6738                                                                 }
6739                                                             }
6740                                                           else
6741                                                             {
6742                                                               if (((word >> 29) & 0x1) == 0)
6743                                                                 {
6744                                                                   /* 33222222222211111111110000000000
6745                                                                      10987654321098765432109876543210
6746                                                                      xxxxxxxxxx0110110xx001xx011110xx
6747                                                                      fcmeq.  */
6748                                                                   return 488;
6749                                                                 }
6750                                                               else
6751                                                                 {
6752                                                                   /* 33222222222211111111110000000000
6753                                                                      10987654321098765432109876543210
6754                                                                      xxxxxxxxxx0110110xx001xx011111xx
6755                                                                      fcmle.  */
6756                                                                   return 518;
6757                                                                 }
6758                                                             }
6759                                                         }
6760                                                       else
6761                                                         {
6762                                                           if (((word >> 29) & 0x1) == 0)
6763                                                             {
6764                                                               /* 33222222222211111111110000000000
6765                                                                  10987654321098765432109876543210
6766                                                                  xxxxxxxxxx0110110xx011xx0111x0xx
6767                                                                  faddp.  */
6768                                                               return 532;
6769                                                             }
6770                                                           else
6771                                                             {
6772                                                               /* 33222222222211111111110000000000
6773                                                                  10987654321098765432109876543210
6774                                                                  xxxxxxxxxx0110110xx011xx0111x1xx
6775                                                                  faddp.  */
6776                                                               return 531;
6777                                                             }
6778                                                         }
6779                                                     }
6780                                                   else
6781                                                     {
6782                                                       if (((word >> 28) & 0x1) == 0)
6783                                                         {
6784                                                           if (((word >> 29) & 0x1) == 0)
6785                                                             {
6786                                                               /* 33222222222211111111110000000000
6787                                                                  10987654321098765432109876543210
6788                                                                  xxxxxxxxxx0110110xx1x1xx011100xx
6789                                                                  fcmeq.  */
6790                                                               return 190;
6791                                                             }
6792                                                           else
6793                                                             {
6794                                                               /* 33222222222211111111110000000000
6795                                                                  10987654321098765432109876543210
6796                                                                  xxxxxxxxxx0110110xx1x1xx011101xx
6797                                                                  fcmle.  */
6798                                                               return 241;
6799                                                             }
6800                                                         }
6801                                                       else
6802                                                         {
6803                                                           if (((word >> 29) & 0x1) == 0)
6804                                                             {
6805                                                               /* 33222222222211111111110000000000
6806                                                                  10987654321098765432109876543210
6807                                                                  xxxxxxxxxx0110110xx1x1xx011110xx
6808                                                                  fcmeq.  */
6809                                                               return 489;
6810                                                             }
6811                                                           else
6812                                                             {
6813                                                               /* 33222222222211111111110000000000
6814                                                                  10987654321098765432109876543210
6815                                                                  xxxxxxxxxx0110110xx1x1xx011111xx
6816                                                                  fcmle.  */
6817                                                               return 519;
6818                                                             }
6819                                                         }
6820                                                     }
6821                                                 }
6822                                               else
6823                                                 {
6824                                                   if (((word >> 19) & 0x1) == 0)
6825                                                     {
6826                                                       if (((word >> 23) & 0x1) == 0)
6827                                                         {
6828                                                           if (((word >> 28) & 0x1) == 0)
6829                                                             {
6830                                                               if (((word >> 29) & 0x1) == 0)
6831                                                                 {
6832                                                                   /* 33222222222211111111110000000000
6833                                                                      10987654321098765432109876543210
6834                                                                      xxxxxxxxxx0110111xx0x1x0011100xx
6835                                                                      scvtf.  */
6836                                                                   return 185;
6837                                                                 }
6838                                                               else
6839                                                                 {
6840                                                                   /* 33222222222211111111110000000000
6841                                                                      10987654321098765432109876543210
6842                                                                      xxxxxxxxxx0110111xx0x1x0011101xx
6843                                                                      ucvtf.  */
6844                                                                   return 233;
6845                                                                 }
6846                                                             }
6847                                                           else
6848                                                             {
6849                                                               if (((word >> 29) & 0x1) == 0)
6850                                                                 {
6851                                                                   /* 33222222222211111111110000000000
6852                                                                      10987654321098765432109876543210
6853                                                                      xxxxxxxxxx0110111xx0x1x0011110xx
6854                                                                      scvtf.  */
6855                                                                   return 484;
6856                                                                 }
6857                                                               else
6858                                                                 {
6859                                                                   /* 33222222222211111111110000000000
6860                                                                      10987654321098765432109876543210
6861                                                                      xxxxxxxxxx0110111xx0x1x0011111xx
6862                                                                      ucvtf.  */
6863                                                                   return 514;
6864                                                                 }
6865                                                             }
6866                                                         }
6867                                                       else
6868                                                         {
6869                                                           if (((word >> 28) & 0x1) == 0)
6870                                                             {
6871                                                               if (((word >> 29) & 0x1) == 0)
6872                                                                 {
6873                                                                   /* 33222222222211111111110000000000
6874                                                                      10987654321098765432109876543210
6875                                                                      xxxxxxxxxx0110111xx0x1x1011100xx
6876                                                                      frecpe.  */
6877                                                                   return 204;
6878                                                                 }
6879                                                               else
6880                                                                 {
6881                                                                   /* 33222222222211111111110000000000
6882                                                                      10987654321098765432109876543210
6883                                                                      xxxxxxxxxx0110111xx0x1x1011101xx
6884                                                                      frsqrte.  */
6885                                                                   return 251;
6886                                                                 }
6887                                                             }
6888                                                           else
6889                                                             {
6890                                                               if (((word >> 29) & 0x1) == 0)
6891                                                                 {
6892                                                                   /* 33222222222211111111110000000000
6893                                                                      10987654321098765432109876543210
6894                                                                      xxxxxxxxxx0110111xx0x1x1011110xx
6895                                                                      frecpe.  */
6896                                                                   return 496;
6897                                                                 }
6898                                                               else
6899                                                                 {
6900                                                                   /* 33222222222211111111110000000000
6901                                                                      10987654321098765432109876543210
6902                                                                      xxxxxxxxxx0110111xx0x1x1011111xx
6903                                                                      frsqrte.  */
6904                                                                   return 524;
6905                                                                 }
6906                                                             }
6907                                                         }
6908                                                     }
6909                                                   else
6910                                                     {
6911                                                       if (((word >> 23) & 0x1) == 0)
6912                                                         {
6913                                                           if (((word >> 28) & 0x1) == 0)
6914                                                             {
6915                                                               if (((word >> 29) & 0x1) == 0)
6916                                                                 {
6917                                                                   /* 33222222222211111111110000000000
6918                                                                      10987654321098765432109876543210
6919                                                                      xxxxxxxxxx0110111xx1x1x0011100xx
6920                                                                      scvtf.  */
6921                                                                   return 186;
6922                                                                 }
6923                                                               else
6924                                                                 {
6925                                                                   /* 33222222222211111111110000000000
6926                                                                      10987654321098765432109876543210
6927                                                                      xxxxxxxxxx0110111xx1x1x0011101xx
6928                                                                      ucvtf.  */
6929                                                                   return 234;
6930                                                                 }
6931                                                             }
6932                                                           else
6933                                                             {
6934                                                               if (((word >> 29) & 0x1) == 0)
6935                                                                 {
6936                                                                   /* 33222222222211111111110000000000
6937                                                                      10987654321098765432109876543210
6938                                                                      xxxxxxxxxx0110111xx1x1x0011110xx
6939                                                                      scvtf.  */
6940                                                                   return 485;
6941                                                                 }
6942                                                               else
6943                                                                 {
6944                                                                   /* 33222222222211111111110000000000
6945                                                                      10987654321098765432109876543210
6946                                                                      xxxxxxxxxx0110111xx1x1x0011111xx
6947                                                                      ucvtf.  */
6948                                                                   return 515;
6949                                                                 }
6950                                                             }
6951                                                         }
6952                                                       else
6953                                                         {
6954                                                           if (((word >> 28) & 0x1) == 0)
6955                                                             {
6956                                                               if (((word >> 29) & 0x1) == 0)
6957                                                                 {
6958                                                                   /* 33222222222211111111110000000000
6959                                                                      10987654321098765432109876543210
6960                                                                      xxxxxxxxxx0110111xx1x1x1011100xx
6961                                                                      frecpe.  */
6962                                                                   return 205;
6963                                                                 }
6964                                                               else
6965                                                                 {
6966                                                                   /* 33222222222211111111110000000000
6967                                                                      10987654321098765432109876543210
6968                                                                      xxxxxxxxxx0110111xx1x1x1011101xx
6969                                                                      frsqrte.  */
6970                                                                   return 252;
6971                                                                 }
6972                                                             }
6973                                                           else
6974                                                             {
6975                                                               if (((word >> 29) & 0x1) == 0)
6976                                                                 {
6977                                                                   /* 33222222222211111111110000000000
6978                                                                      10987654321098765432109876543210
6979                                                                      xxxxxxxxxx0110111xx1x1x1011110xx
6980                                                                      frecpe.  */
6981                                                                   return 497;
6982                                                                 }
6983                                                               else
6984                                                                 {
6985                                                                   /* 33222222222211111111110000000000
6986                                                                      10987654321098765432109876543210
6987                                                                      xxxxxxxxxx0110111xx1x1x1011111xx
6988                                                                      frsqrte.  */
6989                                                                   return 525;
6990                                                                 }
6991                                                             }
6992                                                         }
6993                                                     }
6994                                                 }
6995                                             }
6996                                         }
6997                                     }
6998                                   else
6999                                     {
7000                                       if (((word >> 14) & 0x1) == 0)
7001                                         {
7002                                           if (((word >> 15) & 0x1) == 0)
7003                                             {
7004                                               if (((word >> 28) & 0x1) == 0)
7005                                                 {
7006                                                   if (((word >> 16) & 0x1) == 0)
7007                                                     {
7008                                                       if (((word >> 20) & 0x1) == 0)
7009                                                         {
7010                                                           if (((word >> 29) & 0x1) == 0)
7011                                                             {
7012                                                               /* 33222222222211111111110000000000
7013                                                                  10987654321098765432109876543210
7014                                                                  xxxxxxxxxx0111000xxx01xx011100xx
7015                                                                  suqadd.  */
7016                                                               return 158;
7017                                                             }
7018                                                           else
7019                                                             {
7020                                                               /* 33222222222211111111110000000000
7021                                                                  10987654321098765432109876543210
7022                                                                  xxxxxxxxxx0111000xxx01xx011101xx
7023                                                                  usqadd.  */
7024                                                               return 208;
7025                                                             }
7026                                                         }
7027                                                       else
7028                                                         {
7029                                                           if (((word >> 29) & 0x1) == 0)
7030                                                             {
7031                                                               /* 33222222222211111111110000000000
7032                                                                  10987654321098765432109876543210
7033                                                                  xxxxxxxxxx0111000xxx11xx011100xx
7034                                                                  saddlv.  */
7035                                                               return 27;
7036                                                             }
7037                                                           else
7038                                                             {
7039                                                               /* 33222222222211111111110000000000
7040                                                                  10987654321098765432109876543210
7041                                                                  xxxxxxxxxx0111000xxx11xx011101xx
7042                                                                  uaddlv.  */
7043                                                               return 31;
7044                                                             }
7045                                                         }
7046                                                     }
7047                                                   else
7048                                                     {
7049                                                       if (((word >> 30) & 0x1) == 0)
7050                                                         {
7051                                                           /* 33222222222211111111110000000000
7052                                                              10987654321098765432109876543210
7053                                                              xxxxxxxxxx0111001xxxx1xx01110x0x
7054                                                              shll.  */
7055                                                           return 217;
7056                                                         }
7057                                                       else
7058                                                         {
7059                                                           /* 33222222222211111111110000000000
7060                                                              10987654321098765432109876543210
7061                                                              xxxxxxxxxx0111001xxxx1xx01110x1x
7062                                                              shll2.  */
7063                                                           return 218;
7064                                                         }
7065                                                     }
7066                                                 }
7067                                               else
7068                                                 {
7069                                                   if (((word >> 29) & 0x1) == 0)
7070                                                     {
7071                                                       if (((word >> 30) & 0x1) == 0)
7072                                                         {
7073                                                           /* 33222222222211111111110000000000
7074                                                              10987654321098765432109876543210
7075                                                              xxxxxxxxxx011100xxxxx1xx0111100x
7076                                                              fsub.  */
7077                                                           return 793;
7078                                                         }
7079                                                       else
7080                                                         {
7081                                                           /* 33222222222211111111110000000000
7082                                                              10987654321098765432109876543210
7083                                                              xxxxxxxxxx011100xxxxx1xx0111101x
7084                                                              suqadd.  */
7085                                                           return 471;
7086                                                         }
7087                                                     }
7088                                                   else
7089                                                     {
7090                                                       /* 33222222222211111111110000000000
7091                                                          10987654321098765432109876543210
7092                                                          xxxxxxxxxx011100xxxxx1xx011111xx
7093                                                          usqadd.  */
7094                                                       return 500;
7095                                                     }
7096                                                 }
7097                                             }
7098                                           else
7099                                             {
7100                                               if (((word >> 16) & 0x1) == 0)
7101                                                 {
7102                                                   if (((word >> 28) & 0x1) == 0)
7103                                                     {
7104                                                       if (((word >> 29) & 0x1) == 0)
7105                                                         {
7106                                                           /* 33222222222211111111110000000000
7107                                                              10987654321098765432109876543210
7108                                                              xxxxxxxxxx0111010xxxx1xx011100xx
7109                                                              abs.  */
7110                                                           return 166;
7111                                                         }
7112                                                       else
7113                                                         {
7114                                                           /* 33222222222211111111110000000000
7115                                                              10987654321098765432109876543210
7116                                                              xxxxxxxxxx0111010xxxx1xx011101xx
7117                                                              neg.  */
7118                                                           return 214;
7119                                                         }
7120                                                     }
7121                                                   else
7122                                                     {
7123                                                       if (((word >> 29) & 0x1) == 0)
7124                                                         {
7125                                                           /* 33222222222211111111110000000000
7126                                                              10987654321098765432109876543210
7127                                                              xxxxxxxxxx0111010xxxx1xx011110xx
7128                                                              abs.  */
7129                                                           return 476;
7130                                                         }
7131                                                       else
7132                                                         {
7133                                                           /* 33222222222211111111110000000000
7134                                                              10987654321098765432109876543210
7135                                                              xxxxxxxxxx0111010xxxx1xx011111xx
7136                                                              neg.  */
7137                                                           return 504;
7138                                                         }
7139                                                     }
7140                                                 }
7141                                               else
7142                                                 {
7143                                                   if (((word >> 19) & 0x1) == 0)
7144                                                     {
7145                                                       if (((word >> 20) & 0x1) == 0)
7146                                                         {
7147                                                           if (((word >> 23) & 0x1) == 0)
7148                                                             {
7149                                                               if (((word >> 28) & 0x1) == 0)
7150                                                                 {
7151                                                                   if (((word >> 29) & 0x1) == 0)
7152                                                                     {
7153                                                                       /* 33222222222211111111110000000000
7154                                                                          10987654321098765432109876543210
7155                                                                          xxxxxxxxxx0111011xx001x0011100xx
7156                                                                          fcvtms.  */
7157                                                                       return 181;
7158                                                                     }
7159                                                                   else
7160                                                                     {
7161                                                                       /* 33222222222211111111110000000000
7162                                                                          10987654321098765432109876543210
7163                                                                          xxxxxxxxxx0111011xx001x0011101xx
7164                                                                          fcvtmu.  */
7165                                                                       return 229;
7166                                                                     }
7167                                                                 }
7168                                                               else
7169                                                                 {
7170                                                                   if (((word >> 29) & 0x1) == 0)
7171                                                                     {
7172                                                                       /* 33222222222211111111110000000000
7173                                                                          10987654321098765432109876543210
7174                                                                          xxxxxxxxxx0111011xx001x0011110xx
7175                                                                          fcvtms.  */
7176                                                                       return 480;
7177                                                                     }
7178                                                                   else
7179                                                                     {
7180                                                                       /* 33222222222211111111110000000000
7181                                                                          10987654321098765432109876543210
7182                                                                          xxxxxxxxxx0111011xx001x0011111xx
7183                                                                          fcvtmu.  */
7184                                                                       return 510;
7185                                                                     }
7186                                                                 }
7187                                                             }
7188                                                           else
7189                                                             {
7190                                                               if (((word >> 28) & 0x1) == 0)
7191                                                                 {
7192                                                                   if (((word >> 29) & 0x1) == 0)
7193                                                                     {
7194                                                                       /* 33222222222211111111110000000000
7195                                                                          10987654321098765432109876543210
7196                                                                          xxxxxxxxxx0111011xx001x1011100xx
7197                                                                          fcvtzs.  */
7198                                                                       return 201;
7199                                                                     }
7200                                                                   else
7201                                                                     {
7202                                                                       /* 33222222222211111111110000000000
7203                                                                          10987654321098765432109876543210
7204                                                                          xxxxxxxxxx0111011xx001x1011101xx
7205                                                                          fcvtzu.  */
7206                                                                       return 248;
7207                                                                     }
7208                                                                 }
7209                                                               else
7210                                                                 {
7211                                                                   if (((word >> 29) & 0x1) == 0)
7212                                                                     {
7213                                                                       /* 33222222222211111111110000000000
7214                                                                          10987654321098765432109876543210
7215                                                                          xxxxxxxxxx0111011xx001x1011110xx
7216                                                                          fcvtzs.  */
7217                                                                       return 494;
7218                                                                     }
7219                                                                   else
7220                                                                     {
7221                                                                       /* 33222222222211111111110000000000
7222                                                                          10987654321098765432109876543210
7223                                                                          xxxxxxxxxx0111011xx001x1011111xx
7224                                                                          fcvtzu.  */
7225                                                                       return 522;
7226                                                                     }
7227                                                                 }
7228                                                             }
7229                                                         }
7230                                                       else
7231                                                         {
7232                                                           if (((word >> 28) & 0x1) == 0)
7233                                                             {
7234                                                               /* 33222222222211111111110000000000
7235                                                                  10987654321098765432109876543210
7236                                                                  xxxxxxxxxx0111011xx011xx01110xxx
7237                                                                  addv.  */
7238                                                               return 30;
7239                                                             }
7240                                                           else
7241                                                             {
7242                                                               /* 33222222222211111111110000000000
7243                                                                  10987654321098765432109876543210
7244                                                                  xxxxxxxxxx0111011xx011xx01111xxx
7245                                                                  addp.  */
7246                                                               return 528;
7247                                                             }
7248                                                         }
7249                                                     }
7250                                                   else
7251                                                     {
7252                                                       if (((word >> 23) & 0x1) == 0)
7253                                                         {
7254                                                           if (((word >> 28) & 0x1) == 0)
7255                                                             {
7256                                                               if (((word >> 29) & 0x1) == 0)
7257                                                                 {
7258                                                                   /* 33222222222211111111110000000000
7259                                                                      10987654321098765432109876543210
7260                                                                      xxxxxxxxxx0111011xx1x1x0011100xx
7261                                                                      fcvtms.  */
7262                                                                   return 182;
7263                                                                 }
7264                                                               else
7265                                                                 {
7266                                                                   /* 33222222222211111111110000000000
7267                                                                      10987654321098765432109876543210
7268                                                                      xxxxxxxxxx0111011xx1x1x0011101xx
7269                                                                      fcvtmu.  */
7270                                                                   return 230;
7271                                                                 }
7272                                                             }
7273                                                           else
7274                                                             {
7275                                                               if (((word >> 29) & 0x1) == 0)
7276                                                                 {
7277                                                                   /* 33222222222211111111110000000000
7278                                                                      10987654321098765432109876543210
7279                                                                      xxxxxxxxxx0111011xx1x1x0011110xx
7280                                                                      fcvtms.  */
7281                                                                   return 481;
7282                                                                 }
7283                                                               else
7284                                                                 {
7285                                                                   /* 33222222222211111111110000000000
7286                                                                      10987654321098765432109876543210
7287                                                                      xxxxxxxxxx0111011xx1x1x0011111xx
7288                                                                      fcvtmu.  */
7289                                                                   return 511;
7290                                                                 }
7291                                                             }
7292                                                         }
7293                                                       else
7294                                                         {
7295                                                           if (((word >> 28) & 0x1) == 0)
7296                                                             {
7297                                                               if (((word >> 29) & 0x1) == 0)
7298                                                                 {
7299                                                                   /* 33222222222211111111110000000000
7300                                                                      10987654321098765432109876543210
7301                                                                      xxxxxxxxxx0111011xx1x1x1011100xx
7302                                                                      fcvtzs.  */
7303                                                                   return 202;
7304                                                                 }
7305                                                               else
7306                                                                 {
7307                                                                   /* 33222222222211111111110000000000
7308                                                                      10987654321098765432109876543210
7309                                                                      xxxxxxxxxx0111011xx1x1x1011101xx
7310                                                                      fcvtzu.  */
7311                                                                   return 249;
7312                                                                 }
7313                                                             }
7314                                                           else
7315                                                             {
7316                                                               if (((word >> 29) & 0x1) == 0)
7317                                                                 {
7318                                                                   /* 33222222222211111111110000000000
7319                                                                      10987654321098765432109876543210
7320                                                                      xxxxxxxxxx0111011xx1x1x1011110xx
7321                                                                      fcvtzs.  */
7322                                                                   return 495;
7323                                                                 }
7324                                                               else
7325                                                                 {
7326                                                                   /* 33222222222211111111110000000000
7327                                                                      10987654321098765432109876543210
7328                                                                      xxxxxxxxxx0111011xx1x1x1011111xx
7329                                                                      fcvtzu.  */
7330                                                                   return 523;
7331                                                                 }
7332                                                             }
7333                                                         }
7334                                                     }
7335                                                 }
7336                                             }
7337                                         }
7338                                       else
7339                                         {
7340                                           if (((word >> 15) & 0x1) == 0)
7341                                             {
7342                                               if (((word >> 28) & 0x1) == 0)
7343                                                 {
7344                                                   if (((word >> 16) & 0x1) == 0)
7345                                                     {
7346                                                       if (((word >> 19) & 0x1) == 0)
7347                                                         {
7348                                                           if (((word >> 29) & 0x1) == 0)
7349                                                             {
7350                                                               /* 33222222222211111111110000000000
7351                                                                  10987654321098765432109876543210
7352                                                                  xxxxxxxxxx0111100xx0x1xx011100xx
7353                                                                  sqabs.  */
7354                                                               return 162;
7355                                                             }
7356                                                           else
7357                                                             {
7358                                                               /* 33222222222211111111110000000000
7359                                                                  10987654321098765432109876543210
7360                                                                  xxxxxxxxxx0111100xx0x1xx011101xx
7361                                                                  sqneg.  */
7362                                                               return 211;
7363                                                             }
7364                                                         }
7365                                                       else
7366                                                         {
7367                                                           /* 33222222222211111111110000000000
7368                                                              10987654321098765432109876543210
7369                                                              xxxxxxxxxx0111100xx1x1xx01110xxx
7370                                                              aesimc.  */
7371                                                           return 653;
7372                                                         }
7373                                                     }
7374                                                   else
7375                                                     {
7376                                                       if (((word >> 30) & 0x1) == 0)
7377                                                         {
7378                                                           /* 33222222222211111111110000000000
7379                                                              10987654321098765432109876543210
7380                                                              xxxxxxxxxx0111101xxxx1xx01110x0x
7381                                                              fcvtl.  */
7382                                                           return 173;
7383                                                         }
7384                                                       else
7385                                                         {
7386                                                           /* 33222222222211111111110000000000
7387                                                              10987654321098765432109876543210
7388                                                              xxxxxxxxxx0111101xxxx1xx01110x1x
7389                                                              fcvtl2.  */
7390                                                           return 174;
7391                                                         }
7392                                                     }
7393                                                 }
7394                                               else
7395                                                 {
7396                                                   if (((word >> 29) & 0x1) == 0)
7397                                                     {
7398                                                       if (((word >> 30) & 0x1) == 0)
7399                                                         {
7400                                                           /* 33222222222211111111110000000000
7401                                                              10987654321098765432109876543210
7402                                                              xxxxxxxxxx011110xxxxx1xx0111100x
7403                                                              fminnm.  */
7404                                                           return 801;
7405                                                         }
7406                                                       else
7407                                                         {
7408                                                           /* 33222222222211111111110000000000
7409                                                              10987654321098765432109876543210
7410                                                              xxxxxxxxxx011110xxxxx1xx0111101x
7411                                                              sqabs.  */
7412                                                           return 472;
7413                                                         }
7414                                                     }
7415                                                   else
7416                                                     {
7417                                                       /* 33222222222211111111110000000000
7418                                                          10987654321098765432109876543210
7419                                                          xxxxxxxxxx011110xxxxx1xx011111xx
7420                                                          sqneg.  */
7421                                                       return 501;
7422                                                     }
7423                                                 }
7424                                             }
7425                                           else
7426                                             {
7427                                               if (((word >> 16) & 0x1) == 0)
7428                                                 {
7429                                                   if (((word >> 19) & 0x1) == 0)
7430                                                     {
7431                                                       if (((word >> 20) & 0x1) == 0)
7432                                                         {
7433                                                           if (((word >> 29) & 0x1) == 0)
7434                                                             {
7435                                                               /* 33222222222211111111110000000000
7436                                                                  10987654321098765432109876543210
7437                                                                  xxxxxxxxxx0111110xx001xx0111x0xx
7438                                                                  fabs.  */
7439                                                               return 193;
7440                                                             }
7441                                                           else
7442                                                             {
7443                                                               /* 33222222222211111111110000000000
7444                                                                  10987654321098765432109876543210
7445                                                                  xxxxxxxxxx0111110xx001xx0111x1xx
7446                                                                  fneg.  */
7447                                                               return 242;
7448                                                             }
7449                                                         }
7450                                                       else
7451                                                         {
7452                                                           if (((word >> 23) & 0x1) == 0)
7453                                                             {
7454                                                               if (((word >> 28) & 0x1) == 0)
7455                                                                 {
7456                                                                   if (((word >> 29) & 0x1) == 0)
7457                                                                     {
7458                                                                       /* 33222222222211111111110000000000
7459                                                                          10987654321098765432109876543210
7460                                                                          xxxxxxxxxx0111110xx011x0011100xx
7461                                                                          fmaxv.  */
7462                                                                       return 37;
7463                                                                     }
7464                                                                   else
7465                                                                     {
7466                                                                       /* 33222222222211111111110000000000
7467                                                                          10987654321098765432109876543210
7468                                                                          xxxxxxxxxx0111110xx011x0011101xx
7469                                                                          fmaxv.  */
7470                                                                       return 36;
7471                                                                     }
7472                                                                 }
7473                                                               else
7474                                                                 {
7475                                                                   if (((word >> 29) & 0x1) == 0)
7476                                                                     {
7477                                                                       /* 33222222222211111111110000000000
7478                                                                          10987654321098765432109876543210
7479                                                                          xxxxxxxxxx0111110xx011x0011110xx
7480                                                                          fmaxp.  */
7481                                                                       return 534;
7482                                                                     }
7483                                                                   else
7484                                                                     {
7485                                                                       /* 33222222222211111111110000000000
7486                                                                          10987654321098765432109876543210
7487                                                                          xxxxxxxxxx0111110xx011x0011111xx
7488                                                                          fmaxp.  */
7489                                                                       return 533;
7490                                                                     }
7491                                                                 }
7492                                                             }
7493                                                           else
7494                                                             {
7495                                                               if (((word >> 28) & 0x1) == 0)
7496                                                                 {
7497                                                                   if (((word >> 29) & 0x1) == 0)
7498                                                                     {
7499                                                                       /* 33222222222211111111110000000000
7500                                                                          10987654321098765432109876543210
7501                                                                          xxxxxxxxxx0111110xx011x1011100xx
7502                                                                          fminv.  */
7503                                                                       return 41;
7504                                                                     }
7505                                                                   else
7506                                                                     {
7507                                                                       /* 33222222222211111111110000000000
7508                                                                          10987654321098765432109876543210
7509                                                                          xxxxxxxxxx0111110xx011x1011101xx
7510                                                                          fminv.  */
7511                                                                       return 40;
7512                                                                     }
7513                                                                 }
7514                                                               else
7515                                                                 {
7516                                                                   if (((word >> 29) & 0x1) == 0)
7517                                                                     {
7518                                                                       /* 33222222222211111111110000000000
7519                                                                          10987654321098765432109876543210
7520                                                                          xxxxxxxxxx0111110xx011x1011110xx
7521                                                                          fminp.  */
7522                                                                       return 538;
7523                                                                     }
7524                                                                   else
7525                                                                     {
7526                                                                       /* 33222222222211111111110000000000
7527                                                                          10987654321098765432109876543210
7528                                                                          xxxxxxxxxx0111110xx011x1011111xx
7529                                                                          fminp.  */
7530                                                                       return 537;
7531                                                                     }
7532                                                                 }
7533                                                             }
7534                                                         }
7535                                                     }
7536                                                   else
7537                                                     {
7538                                                       if (((word >> 29) & 0x1) == 0)
7539                                                         {
7540                                                           /* 33222222222211111111110000000000
7541                                                              10987654321098765432109876543210
7542                                                              xxxxxxxxxx0111110xx1x1xx0111x0xx
7543                                                              fabs.  */
7544                                                           return 194;
7545                                                         }
7546                                                       else
7547                                                         {
7548                                                           /* 33222222222211111111110000000000
7549                                                              10987654321098765432109876543210
7550                                                              xxxxxxxxxx0111110xx1x1xx0111x1xx
7551                                                              fneg.  */
7552                                                           return 243;
7553                                                         }
7554                                                     }
7555                                                 }
7556                                               else
7557                                                 {
7558                                                   if (((word >> 19) & 0x1) == 0)
7559                                                     {
7560                                                       if (((word >> 28) & 0x1) == 0)
7561                                                         {
7562                                                           /* 33222222222211111111110000000000
7563                                                              10987654321098765432109876543210
7564                                                              xxxxxxxxxx0111111xx0x1xx01110xxx
7565                                                              fsqrt.  */
7566                                                           return 253;
7567                                                         }
7568                                                       else
7569                                                         {
7570                                                           /* 33222222222211111111110000000000
7571                                                              10987654321098765432109876543210
7572                                                              xxxxxxxxxx0111111xx0x1xx01111xxx
7573                                                              frecpx.  */
7574                                                           return 498;
7575                                                         }
7576                                                     }
7577                                                   else
7578                                                     {
7579                                                       if (((word >> 28) & 0x1) == 0)
7580                                                         {
7581                                                           /* 33222222222211111111110000000000
7582                                                              10987654321098765432109876543210
7583                                                              xxxxxxxxxx0111111xx1x1xx01110xxx
7584                                                              fsqrt.  */
7585                                                           return 254;
7586                                                         }
7587                                                       else
7588                                                         {
7589                                                           /* 33222222222211111111110000000000
7590                                                              10987654321098765432109876543210
7591                                                              xxxxxxxxxx0111111xx1x1xx01111xxx
7592                                                              frecpx.  */
7593                                                           return 499;
7594                                                         }
7595                                                     }
7596                                                 }
7597                                             }
7598                                         }
7599                                     }
7600                                 }
7601                             }
7602                         }
7603                       else
7604                         {
7605                           if (((word >> 11) & 0x1) == 0)
7606                             {
7607                               if (((word >> 28) & 0x1) == 0)
7608                                 {
7609                                   if (((word >> 12) & 0x1) == 0)
7610                                     {
7611                                       if (((word >> 13) & 0x1) == 0)
7612                                         {
7613                                           if (((word >> 14) & 0x1) == 0)
7614                                             {
7615                                               if (((word >> 15) & 0x1) == 0)
7616                                                 {
7617                                                   if (((word >> 29) & 0x1) == 0)
7618                                                     {
7619                                                       /* 33222222222211111111110000000000
7620                                                          10987654321098765432109876543210
7621                                                          xxxxxxxxxx100000xxxxx1xx011100xx
7622                                                          shadd.  */
7623                                                       return 261;
7624                                                     }
7625                                                   else
7626                                                     {
7627                                                       /* 33222222222211111111110000000000
7628                                                          10987654321098765432109876543210
7629                                                          xxxxxxxxxx100000xxxxx1xx011101xx
7630                                                          uhadd.  */
7631                                                       return 313;
7632                                                     }
7633                                                 }
7634                                               else
7635                                                 {
7636                                                   if (((word >> 29) & 0x1) == 0)
7637                                                     {
7638                                                       /* 33222222222211111111110000000000
7639                                                          10987654321098765432109876543210
7640                                                          xxxxxxxxxx100001xxxxx1xx011100xx
7641                                                          add.  */
7642                                                       return 276;
7643                                                     }
7644                                                   else
7645                                                     {
7646                                                       /* 33222222222211111111110000000000
7647                                                          10987654321098765432109876543210
7648                                                          xxxxxxxxxx100001xxxxx1xx011101xx
7649                                                          sub.  */
7650                                                       return 328;
7651                                                     }
7652                                                 }
7653                                             }
7654                                           else
7655                                             {
7656                                               if (((word >> 15) & 0x1) == 0)
7657                                                 {
7658                                                   if (((word >> 29) & 0x1) == 0)
7659                                                     {
7660                                                       /* 33222222222211111111110000000000
7661                                                          10987654321098765432109876543210
7662                                                          xxxxxxxxxx100010xxxxx1xx011100xx
7663                                                          sshl.  */
7664                                                       return 268;
7665                                                     }
7666                                                   else
7667                                                     {
7668                                                       /* 33222222222211111111110000000000
7669                                                          10987654321098765432109876543210
7670                                                          xxxxxxxxxx100010xxxxx1xx011101xx
7671                                                          ushl.  */
7672                                                       return 320;
7673                                                     }
7674                                                 }
7675                                               else
7676                                                 {
7677                                                   if (((word >> 23) & 0x1) == 0)
7678                                                     {
7679                                                       if (((word >> 29) & 0x1) == 0)
7680                                                         {
7681                                                           /* 33222222222211111111110000000000
7682                                                              10987654321098765432109876543210
7683                                                              xxxxxxxxxx100011xxxxx1x0011100xx
7684                                                              fmaxnm.  */
7685                                                           return 284;
7686                                                         }
7687                                                       else
7688                                                         {
7689                                                           /* 33222222222211111111110000000000
7690                                                              10987654321098765432109876543210
7691                                                              xxxxxxxxxx100011xxxxx1x0011101xx
7692                                                              fmaxnmp.  */
7693                                                           return 335;
7694                                                         }
7695                                                     }
7696                                                   else
7697                                                     {
7698                                                       if (((word >> 29) & 0x1) == 0)
7699                                                         {
7700                                                           /* 33222222222211111111110000000000
7701                                                              10987654321098765432109876543210
7702                                                              xxxxxxxxxx100011xxxxx1x1011100xx
7703                                                              fminnm.  */
7704                                                           return 300;
7705                                                         }
7706                                                       else
7707                                                         {
7708                                                           /* 33222222222211111111110000000000
7709                                                              10987654321098765432109876543210
7710                                                              xxxxxxxxxx100011xxxxx1x1011101xx
7711                                                              fminnmp.  */
7712                                                           return 351;
7713                                                         }
7714                                                     }
7715                                                 }
7716                                             }
7717                                         }
7718                                       else
7719                                         {
7720                                           if (((word >> 14) & 0x1) == 0)
7721                                             {
7722                                               if (((word >> 15) & 0x1) == 0)
7723                                                 {
7724                                                   if (((word >> 29) & 0x1) == 0)
7725                                                     {
7726                                                       /* 33222222222211111111110000000000
7727                                                          10987654321098765432109876543210
7728                                                          xxxxxxxxxx100100xxxxx1xx011100xx
7729                                                          shsub.  */
7730                                                       return 264;
7731                                                     }
7732                                                   else
7733                                                     {
7734                                                       /* 33222222222211111111110000000000
7735                                                          10987654321098765432109876543210
7736                                                          xxxxxxxxxx100100xxxxx1xx011101xx
7737                                                          uhsub.  */
7738                                                       return 316;
7739                                                     }
7740                                                 }
7741                                               else
7742                                                 {
7743                                                   if (((word >> 29) & 0x1) == 0)
7744                                                     {
7745                                                       /* 33222222222211111111110000000000
7746                                                          10987654321098765432109876543210
7747                                                          xxxxxxxxxx100101xxxxx1xx011100xx
7748                                                          smaxp.  */
7749                                                       return 280;
7750                                                     }
7751                                                   else
7752                                                     {
7753                                                       /* 33222222222211111111110000000000
7754                                                          10987654321098765432109876543210
7755                                                          xxxxxxxxxx100101xxxxx1xx011101xx
7756                                                          umaxp.  */
7757                                                       return 332;
7758                                                     }
7759                                                 }
7760                                             }
7761                                           else
7762                                             {
7763                                               if (((word >> 15) & 0x1) == 0)
7764                                                 {
7765                                                   if (((word >> 29) & 0x1) == 0)
7766                                                     {
7767                                                       /* 33222222222211111111110000000000
7768                                                          10987654321098765432109876543210
7769                                                          xxxxxxxxxx100110xxxxx1xx011100xx
7770                                                          smax.  */
7771                                                       return 272;
7772                                                     }
7773                                                   else
7774                                                     {
7775                                                       /* 33222222222211111111110000000000
7776                                                          10987654321098765432109876543210
7777                                                          xxxxxxxxxx100110xxxxx1xx011101xx
7778                                                          umax.  */
7779                                                       return 324;
7780                                                     }
7781                                                 }
7782                                               else
7783                                                 {
7784                                                   if (((word >> 23) & 0x1) == 0)
7785                                                     {
7786                                                       if (((word >> 29) & 0x1) == 0)
7787                                                         {
7788                                                           /* 33222222222211111111110000000000
7789                                                              10987654321098765432109876543210
7790                                                              xxxxxxxxxx100111xxxxx1x0011100xx
7791                                                              fcmeq.  */
7792                                                           return 292;
7793                                                         }
7794                                                       else
7795                                                         {
7796                                                           /* 33222222222211111111110000000000
7797                                                              10987654321098765432109876543210
7798                                                              xxxxxxxxxx100111xxxxx1x0011101xx
7799                                                              fcmge.  */
7800                                                           return 341;
7801                                                         }
7802                                                     }
7803                                                   else
7804                                                     {
7805                                                       /* 33222222222211111111110000000000
7806                                                          10987654321098765432109876543210
7807                                                          xxxxxxxxxx100111xxxxx1x101110xxx
7808                                                          fcmgt.  */
7809                                                       return 355;
7810                                                     }
7811                                                 }
7812                                             }
7813                                         }
7814                                     }
7815                                   else
7816                                     {
7817                                       if (((word >> 13) & 0x1) == 0)
7818                                         {
7819                                           if (((word >> 14) & 0x1) == 0)
7820                                             {
7821                                               if (((word >> 15) & 0x1) == 0)
7822                                                 {
7823                                                   if (((word >> 29) & 0x1) == 0)
7824                                                     {
7825                                                       /* 33222222222211111111110000000000
7826                                                          10987654321098765432109876543210
7827                                                          xxxxxxxxxx101000xxxxx1xx011100xx
7828                                                          srhadd.  */
7829                                                       return 263;
7830                                                     }
7831                                                   else
7832                                                     {
7833                                                       /* 33222222222211111111110000000000
7834                                                          10987654321098765432109876543210
7835                                                          xxxxxxxxxx101000xxxxx1xx011101xx
7836                                                          urhadd.  */
7837                                                       return 315;
7838                                                     }
7839                                                 }
7840                                               else
7841                                                 {
7842                                                   if (((word >> 29) & 0x1) == 0)
7843                                                     {
7844                                                       /* 33222222222211111111110000000000
7845                                                          10987654321098765432109876543210
7846                                                          xxxxxxxxxx101001xxxxx1xx011100xx
7847                                                          mla.  */
7848                                                       return 278;
7849                                                     }
7850                                                   else
7851                                                     {
7852                                                       /* 33222222222211111111110000000000
7853                                                          10987654321098765432109876543210
7854                                                          xxxxxxxxxx101001xxxxx1xx011101xx
7855                                                          mls.  */
7856                                                       return 330;
7857                                                     }
7858                                                 }
7859                                             }
7860                                           else
7861                                             {
7862                                               if (((word >> 15) & 0x1) == 0)
7863                                                 {
7864                                                   if (((word >> 29) & 0x1) == 0)
7865                                                     {
7866                                                       /* 33222222222211111111110000000000
7867                                                          10987654321098765432109876543210
7868                                                          xxxxxxxxxx101010xxxxx1xx011100xx
7869                                                          srshl.  */
7870                                                       return 270;
7871                                                     }
7872                                                   else
7873                                                     {
7874                                                       /* 33222222222211111111110000000000
7875                                                          10987654321098765432109876543210
7876                                                          xxxxxxxxxx101010xxxxx1xx011101xx
7877                                                          urshl.  */
7878                                                       return 322;
7879                                                     }
7880                                                 }
7881                                               else
7882                                                 {
7883                                                   if (((word >> 23) & 0x1) == 0)
7884                                                     {
7885                                                       if (((word >> 29) & 0x1) == 0)
7886                                                         {
7887                                                           /* 33222222222211111111110000000000
7888                                                              10987654321098765432109876543210
7889                                                              xxxxxxxxxx101011xxxxx1x0011100xx
7890                                                              fadd.  */
7891                                                           return 288;
7892                                                         }
7893                                                       else
7894                                                         {
7895                                                           /* 33222222222211111111110000000000
7896                                                              10987654321098765432109876543210
7897                                                              xxxxxxxxxx101011xxxxx1x0011101xx
7898                                                              faddp.  */
7899                                                           return 337;
7900                                                         }
7901                                                     }
7902                                                   else
7903                                                     {
7904                                                       if (((word >> 29) & 0x1) == 0)
7905                                                         {
7906                                                           /* 33222222222211111111110000000000
7907                                                              10987654321098765432109876543210
7908                                                              xxxxxxxxxx101011xxxxx1x1011100xx
7909                                                              fsub.  */
7910                                                           return 304;
7911                                                         }
7912                                                       else
7913                                                         {
7914                                                           /* 33222222222211111111110000000000
7915                                                              10987654321098765432109876543210
7916                                                              xxxxxxxxxx101011xxxxx1x1011101xx
7917                                                              fabd.  */
7918                                                           return 353;
7919                                                         }
7920                                                     }
7921                                                 }
7922                                             }
7923                                         }
7924                                       else
7925                                         {
7926                                           if (((word >> 14) & 0x1) == 0)
7927                                             {
7928                                               if (((word >> 15) & 0x1) == 0)
7929                                                 {
7930                                                   if (((word >> 29) & 0x1) == 0)
7931                                                     {
7932                                                       /* 33222222222211111111110000000000
7933                                                          10987654321098765432109876543210
7934                                                          xxxxxxxxxx101100xxxxx1xx011100xx
7935                                                          cmgt.  */
7936                                                       return 266;
7937                                                     }
7938                                                   else
7939                                                     {
7940                                                       /* 33222222222211111111110000000000
7941                                                          10987654321098765432109876543210
7942                                                          xxxxxxxxxx101100xxxxx1xx011101xx
7943                                                          cmhi.  */
7944                                                       return 318;
7945                                                     }
7946                                                 }
7947                                               else
7948                                                 {
7949                                                   if (((word >> 29) & 0x1) == 0)
7950                                                     {
7951                                                       /* 33222222222211111111110000000000
7952                                                          10987654321098765432109876543210
7953                                                          xxxxxxxxxx101101xxxxx1xx011100xx
7954                                                          sqdmulh.  */
7955                                                       return 282;
7956                                                     }
7957                                                   else
7958                                                     {
7959                                                       /* 33222222222211111111110000000000
7960                                                          10987654321098765432109876543210
7961                                                          xxxxxxxxxx101101xxxxx1xx011101xx
7962                                                          sqrdmulh.  */
7963                                                       return 334;
7964                                                     }
7965                                                 }
7966                                             }
7967                                           else
7968                                             {
7969                                               if (((word >> 15) & 0x1) == 0)
7970                                                 {
7971                                                   if (((word >> 29) & 0x1) == 0)
7972                                                     {
7973                                                       /* 33222222222211111111110000000000
7974                                                          10987654321098765432109876543210
7975                                                          xxxxxxxxxx101110xxxxx1xx011100xx
7976                                                          sabd.  */
7977                                                       return 274;
7978                                                     }
7979                                                   else
7980                                                     {
7981                                                       /* 33222222222211111111110000000000
7982                                                          10987654321098765432109876543210
7983                                                          xxxxxxxxxx101110xxxxx1xx011101xx
7984                                                          uabd.  */
7985                                                       return 326;
7986                                                     }
7987                                                 }
7988                                               else
7989                                                 {
7990                                                   if (((word >> 23) & 0x1) == 0)
7991                                                     {
7992                                                       if (((word >> 29) & 0x1) == 0)
7993                                                         {
7994                                                           /* 33222222222211111111110000000000
7995                                                              10987654321098765432109876543210
7996                                                              xxxxxxxxxx101111xxxxx1x0011100xx
7997                                                              fmax.  */
7998                                                           return 294;
7999                                                         }
8000                                                       else
8001                                                         {
8002                                                           /* 33222222222211111111110000000000
8003                                                              10987654321098765432109876543210
8004                                                              xxxxxxxxxx101111xxxxx1x0011101xx
8005                                                              fmaxp.  */
8006                                                           return 345;
8007                                                         }
8008                                                     }
8009                                                   else
8010                                                     {
8011                                                       if (((word >> 29) & 0x1) == 0)
8012                                                         {
8013                                                           /* 33222222222211111111110000000000
8014                                                              10987654321098765432109876543210
8015                                                              xxxxxxxxxx101111xxxxx1x1011100xx
8016                                                              fmin.  */
8017                                                           return 306;
8018                                                         }
8019                                                       else
8020                                                         {
8021                                                           /* 33222222222211111111110000000000
8022                                                              10987654321098765432109876543210
8023                                                              xxxxxxxxxx101111xxxxx1x1011101xx
8024                                                              fminp.  */
8025                                                           return 359;
8026                                                         }
8027                                                     }
8028                                                 }
8029                                             }
8030                                         }
8031                                     }
8032                                 }
8033                               else
8034                                 {
8035                                   if (((word >> 29) & 0x1) == 0)
8036                                     {
8037                                       if (((word >> 30) & 0x1) == 0)
8038                                         {
8039                                           if (((word >> 4) & 0x1) == 0)
8040                                             {
8041                                               /* 33222222222211111111110000000000
8042                                                  10987654321098765432109876543210
8043                                                  xxxx0xxxxx10xxxxxxxxx1xx0111100x
8044                                                  fccmp.  */
8045                                               return 752;
8046                                             }
8047                                           else
8048                                             {
8049                                               /* 33222222222211111111110000000000
8050                                                  10987654321098765432109876543210
8051                                                  xxxx1xxxxx10xxxxxxxxx1xx0111100x
8052                                                  fccmpe.  */
8053                                               return 754;
8054                                             }
8055                                         }
8056                                       else
8057                                         {
8058                                           if (((word >> 12) & 0x1) == 0)
8059                                             {
8060                                               if (((word >> 13) & 0x1) == 0)
8061                                                 {
8062                                                   if (((word >> 14) & 0x1) == 0)
8063                                                     {
8064                                                       /* 33222222222211111111110000000000
8065                                                          10987654321098765432109876543210
8066                                                          xxxxxxxxxx10000xxxxxx1xx0111101x
8067                                                          add.  */
8068                                                       return 556;
8069                                                     }
8070                                                   else
8071                                                     {
8072                                                       /* 33222222222211111111110000000000
8073                                                          10987654321098765432109876543210
8074                                                          xxxxxxxxxx10001xxxxxx1xx0111101x
8075                                                          sshl.  */
8076                                                       return 554;
8077                                                     }
8078                                                 }
8079                                               else
8080                                                 {
8081                                                   /* 33222222222211111111110000000000
8082                                                      10987654321098765432109876543210
8083                                                      xxxxxxxxxx1001xxxxxxx1xx0111101x
8084                                                      fcmeq.  */
8085                                                   return 546;
8086                                                 }
8087                                             }
8088                                           else
8089                                             {
8090                                               if (((word >> 13) & 0x1) == 0)
8091                                                 {
8092                                                   /* 33222222222211111111110000000000
8093                                                      10987654321098765432109876543210
8094                                                      xxxxxxxxxx1010xxxxxxx1xx0111101x
8095                                                      srshl.  */
8096                                                   return 555;
8097                                                 }
8098                                               else
8099                                                 {
8100                                                   if (((word >> 15) & 0x1) == 0)
8101                                                     {
8102                                                       /* 33222222222211111111110000000000
8103                                                          10987654321098765432109876543210
8104                                                          xxxxxxxxxx1011x0xxxxx1xx0111101x
8105                                                          cmgt.  */
8106                                                       return 552;
8107                                                     }
8108                                                   else
8109                                                     {
8110                                                       /* 33222222222211111111110000000000
8111                                                          10987654321098765432109876543210
8112                                                          xxxxxxxxxx1011x1xxxxx1xx0111101x
8113                                                          sqdmulh.  */
8114                                                       return 543;
8115                                                     }
8116                                                 }
8117                                             }
8118                                         }
8119                                     }
8120                                   else
8121                                     {
8122                                       if (((word >> 12) & 0x1) == 0)
8123                                         {
8124                                           if (((word >> 13) & 0x1) == 0)
8125                                             {
8126                                               if (((word >> 14) & 0x1) == 0)
8127                                                 {
8128                                                   /* 33222222222211111111110000000000
8129                                                      10987654321098765432109876543210
8130                                                      xxxxxxxxxx10000xxxxxx1xx011111xx
8131                                                      sub.  */
8132                                                   return 577;
8133                                                 }
8134                                               else
8135                                                 {
8136                                                   /* 33222222222211111111110000000000
8137                                                      10987654321098765432109876543210
8138                                                      xxxxxxxxxx10001xxxxxx1xx011111xx
8139                                                      ushl.  */
8140                                                   return 575;
8141                                                 }
8142                                             }
8143                                           else
8144                                             {
8145                                               if (((word >> 23) & 0x1) == 0)
8146                                                 {
8147                                                   /* 33222222222211111111110000000000
8148                                                      10987654321098765432109876543210
8149                                                      xxxxxxxxxx1001xxxxxxx1x0011111xx
8150                                                      fcmge.  */
8151                                                   return 563;
8152                                                 }
8153                                               else
8154                                                 {
8155                                                   /* 33222222222211111111110000000000
8156                                                      10987654321098765432109876543210
8157                                                      xxxxxxxxxx1001xxxxxxx1x1011111xx
8158                                                      fcmgt.  */
8159                                                   return 569;
8160                                                 }
8161                                             }
8162                                         }
8163                                       else
8164                                         {
8165                                           if (((word >> 13) & 0x1) == 0)
8166                                             {
8167                                               if (((word >> 15) & 0x1) == 0)
8168                                                 {
8169                                                   /* 33222222222211111111110000000000
8170                                                      10987654321098765432109876543210
8171                                                      xxxxxxxxxx1010x0xxxxx1xx011111xx
8172                                                      urshl.  */
8173                                                   return 576;
8174                                                 }
8175                                               else
8176                                                 {
8177                                                   /* 33222222222211111111110000000000
8178                                                      10987654321098765432109876543210
8179                                                      xxxxxxxxxx1010x1xxxxx1xx011111xx
8180                                                      fabd.  */
8181                                                   return 567;
8182                                                 }
8183                                             }
8184                                           else
8185                                             {
8186                                               if (((word >> 15) & 0x1) == 0)
8187                                                 {
8188                                                   /* 33222222222211111111110000000000
8189                                                      10987654321098765432109876543210
8190                                                      xxxxxxxxxx1011x0xxxxx1xx011111xx
8191                                                      cmhi.  */
8192                                                   return 573;
8193                                                 }
8194                                               else
8195                                                 {
8196                                                   /* 33222222222211111111110000000000
8197                                                      10987654321098765432109876543210
8198                                                      xxxxxxxxxx1011x1xxxxx1xx011111xx
8199                                                      sqrdmulh.  */
8200                                                   return 562;
8201                                                 }
8202                                             }
8203                                         }
8204                                     }
8205                                 }
8206                             }
8207                           else
8208                             {
8209                               if (((word >> 28) & 0x1) == 0)
8210                                 {
8211                                   if (((word >> 12) & 0x1) == 0)
8212                                     {
8213                                       if (((word >> 13) & 0x1) == 0)
8214                                         {
8215                                           if (((word >> 14) & 0x1) == 0)
8216                                             {
8217                                               if (((word >> 15) & 0x1) == 0)
8218                                                 {
8219                                                   if (((word >> 29) & 0x1) == 0)
8220                                                     {
8221                                                       /* 33222222222211111111110000000000
8222                                                          10987654321098765432109876543210
8223                                                          xxxxxxxxxx110000xxxxx1xx011100xx
8224                                                          sqadd.  */
8225                                                       return 262;
8226                                                     }
8227                                                   else
8228                                                     {
8229                                                       /* 33222222222211111111110000000000
8230                                                          10987654321098765432109876543210
8231                                                          xxxxxxxxxx110000xxxxx1xx011101xx
8232                                                          uqadd.  */
8233                                                       return 314;
8234                                                     }
8235                                                 }
8236                                               else
8237                                                 {
8238                                                   if (((word >> 29) & 0x1) == 0)
8239                                                     {
8240                                                       /* 33222222222211111111110000000000
8241                                                          10987654321098765432109876543210
8242                                                          xxxxxxxxxx110001xxxxx1xx011100xx
8243                                                          cmtst.  */
8244                                                       return 277;
8245                                                     }
8246                                                   else
8247                                                     {
8248                                                       /* 33222222222211111111110000000000
8249                                                          10987654321098765432109876543210
8250                                                          xxxxxxxxxx110001xxxxx1xx011101xx
8251                                                          cmeq.  */
8252                                                       return 329;
8253                                                     }
8254                                                 }
8255                                             }
8256                                           else
8257                                             {
8258                                               if (((word >> 15) & 0x1) == 0)
8259                                                 {
8260                                                   if (((word >> 29) & 0x1) == 0)
8261                                                     {
8262                                                       /* 33222222222211111111110000000000
8263                                                          10987654321098765432109876543210
8264                                                          xxxxxxxxxx110010xxxxx1xx011100xx
8265                                                          sqshl.  */
8266                                                       return 269;
8267                                                     }
8268                                                   else
8269                                                     {
8270                                                       /* 33222222222211111111110000000000
8271                                                          10987654321098765432109876543210
8272                                                          xxxxxxxxxx110010xxxxx1xx011101xx
8273                                                          uqshl.  */
8274                                                       return 321;
8275                                                     }
8276                                                 }
8277                                               else
8278                                                 {
8279                                                   if (((word >> 23) & 0x1) == 0)
8280                                                     {
8281                                                       /* 33222222222211111111110000000000
8282                                                          10987654321098765432109876543210
8283                                                          xxxxxxxxxx110011xxxxx1x001110xxx
8284                                                          fmla.  */
8285                                                       return 286;
8286                                                     }
8287                                                   else
8288                                                     {
8289                                                       /* 33222222222211111111110000000000
8290                                                          10987654321098765432109876543210
8291                                                          xxxxxxxxxx110011xxxxx1x101110xxx
8292                                                          fmls.  */
8293                                                       return 302;
8294                                                     }
8295                                                 }
8296                                             }
8297                                         }
8298                                       else
8299                                         {
8300                                           if (((word >> 14) & 0x1) == 0)
8301                                             {
8302                                               if (((word >> 15) & 0x1) == 0)
8303                                                 {
8304                                                   if (((word >> 29) & 0x1) == 0)
8305                                                     {
8306                                                       /* 33222222222211111111110000000000
8307                                                          10987654321098765432109876543210
8308                                                          xxxxxxxxxx110100xxxxx1xx011100xx
8309                                                          sqsub.  */
8310                                                       return 265;
8311                                                     }
8312                                                   else
8313                                                     {
8314                                                       /* 33222222222211111111110000000000
8315                                                          10987654321098765432109876543210
8316                                                          xxxxxxxxxx110100xxxxx1xx011101xx
8317                                                          uqsub.  */
8318                                                       return 317;
8319                                                     }
8320                                                 }
8321                                               else
8322                                                 {
8323                                                   if (((word >> 29) & 0x1) == 0)
8324                                                     {
8325                                                       /* 33222222222211111111110000000000
8326                                                          10987654321098765432109876543210
8327                                                          xxxxxxxxxx110101xxxxx1xx011100xx
8328                                                          sminp.  */
8329                                                       return 281;
8330                                                     }
8331                                                   else
8332                                                     {
8333                                                       /* 33222222222211111111110000000000
8334                                                          10987654321098765432109876543210
8335                                                          xxxxxxxxxx110101xxxxx1xx011101xx
8336                                                          uminp.  */
8337                                                       return 333;
8338                                                     }
8339                                                 }
8340                                             }
8341                                           else
8342                                             {
8343                                               if (((word >> 15) & 0x1) == 0)
8344                                                 {
8345                                                   if (((word >> 29) & 0x1) == 0)
8346                                                     {
8347                                                       /* 33222222222211111111110000000000
8348                                                          10987654321098765432109876543210
8349                                                          xxxxxxxxxx110110xxxxx1xx011100xx
8350                                                          smin.  */
8351                                                       return 273;
8352                                                     }
8353                                                   else
8354                                                     {
8355                                                       /* 33222222222211111111110000000000
8356                                                          10987654321098765432109876543210
8357                                                          xxxxxxxxxx110110xxxxx1xx011101xx
8358                                                          umin.  */
8359                                                       return 325;
8360                                                     }
8361                                                 }
8362                                               else
8363                                                 {
8364                                                   if (((word >> 23) & 0x1) == 0)
8365                                                     {
8366                                                       /* 33222222222211111111110000000000
8367                                                          10987654321098765432109876543210
8368                                                          xxxxxxxxxx110111xxxxx1x001110xxx
8369                                                          facge.  */
8370                                                       return 343;
8371                                                     }
8372                                                   else
8373                                                     {
8374                                                       /* 33222222222211111111110000000000
8375                                                          10987654321098765432109876543210
8376                                                          xxxxxxxxxx110111xxxxx1x101110xxx
8377                                                          facgt.  */
8378                                                       return 357;
8379                                                     }
8380                                                 }
8381                                             }
8382                                         }
8383                                     }
8384                                   else
8385                                     {
8386                                       if (((word >> 13) & 0x1) == 0)
8387                                         {
8388                                           if (((word >> 14) & 0x1) == 0)
8389                                             {
8390                                               if (((word >> 15) & 0x1) == 0)
8391                                                 {
8392                                                   if (((word >> 22) & 0x1) == 0)
8393                                                     {
8394                                                       if (((word >> 23) & 0x1) == 0)
8395                                                         {
8396                                                           if (((word >> 29) & 0x1) == 0)
8397                                                             {
8398                                                               /* 33222222222211111111110000000000
8399                                                                  10987654321098765432109876543210
8400                                                                  xxxxxxxxxx111000xxxxx100011100xx
8401                                                                  and.  */
8402                                                               return 298;
8403                                                             }
8404                                                           else
8405                                                             {
8406                                                               /* 33222222222211111111110000000000
8407                                                                  10987654321098765432109876543210
8408                                                                  xxxxxxxxxx111000xxxxx100011101xx
8409                                                                  eor.  */
8410                                                               return 349;
8411                                                             }
8412                                                         }
8413                                                       else
8414                                                         {
8415                                                           if (((word >> 29) & 0x1) == 0)
8416                                                             {
8417                                                               /* 33222222222211111111110000000000
8418                                                                  10987654321098765432109876543210
8419                                                                  xxxxxxxxxx111000xxxxx101011100xx
8420                                                                  orr.  */
8421                                                               return 310;
8422                                                             }
8423                                                           else
8424                                                             {
8425                                                               /* 33222222222211111111110000000000
8426                                                                  10987654321098765432109876543210
8427                                                                  xxxxxxxxxx111000xxxxx101011101xx
8428                                                                  bit.  */
8429                                                               return 361;
8430                                                             }
8431                                                         }
8432                                                     }
8433                                                   else
8434                                                     {
8435                                                       if (((word >> 23) & 0x1) == 0)
8436                                                         {
8437                                                           if (((word >> 29) & 0x1) == 0)
8438                                                             {
8439                                                               /* 33222222222211111111110000000000
8440                                                                  10987654321098765432109876543210
8441                                                                  xxxxxxxxxx111000xxxxx110011100xx
8442                                                                  bic.  */
8443                                                               return 299;
8444                                                             }
8445                                                           else
8446                                                             {
8447                                                               /* 33222222222211111111110000000000
8448                                                                  10987654321098765432109876543210
8449                                                                  xxxxxxxxxx111000xxxxx110011101xx
8450                                                                  bsl.  */
8451                                                               return 350;
8452                                                             }
8453                                                         }
8454                                                       else
8455                                                         {
8456                                                           if (((word >> 29) & 0x1) == 0)
8457                                                             {
8458                                                               /* 33222222222211111111110000000000
8459                                                                  10987654321098765432109876543210
8460                                                                  xxxxxxxxxx111000xxxxx111011100xx
8461                                                                  orn.  */
8462                                                               return 312;
8463                                                             }
8464                                                           else
8465                                                             {
8466                                                               /* 33222222222211111111110000000000
8467                                                                  10987654321098765432109876543210
8468                                                                  xxxxxxxxxx111000xxxxx111011101xx
8469                                                                  bif.  */
8470                                                               return 362;
8471                                                             }
8472                                                         }
8473                                                     }
8474                                                 }
8475                                               else
8476                                                 {
8477                                                   if (((word >> 29) & 0x1) == 0)
8478                                                     {
8479                                                       /* 33222222222211111111110000000000
8480                                                          10987654321098765432109876543210
8481                                                          xxxxxxxxxx111001xxxxx1xx011100xx
8482                                                          mul.  */
8483                                                       return 279;
8484                                                     }
8485                                                   else
8486                                                     {
8487                                                       /* 33222222222211111111110000000000
8488                                                          10987654321098765432109876543210
8489                                                          xxxxxxxxxx111001xxxxx1xx011101xx
8490                                                          pmul.  */
8491                                                       return 331;
8492                                                     }
8493                                                 }
8494                                             }
8495                                           else
8496                                             {
8497                                               if (((word >> 15) & 0x1) == 0)
8498                                                 {
8499                                                   if (((word >> 29) & 0x1) == 0)
8500                                                     {
8501                                                       /* 33222222222211111111110000000000
8502                                                          10987654321098765432109876543210
8503                                                          xxxxxxxxxx111010xxxxx1xx011100xx
8504                                                          sqrshl.  */
8505                                                       return 271;
8506                                                     }
8507                                                   else
8508                                                     {
8509                                                       /* 33222222222211111111110000000000
8510                                                          10987654321098765432109876543210
8511                                                          xxxxxxxxxx111010xxxxx1xx011101xx
8512                                                          uqrshl.  */
8513                                                       return 323;
8514                                                     }
8515                                                 }
8516                                               else
8517                                                 {
8518                                                   if (((word >> 29) & 0x1) == 0)
8519                                                     {
8520                                                       /* 33222222222211111111110000000000
8521                                                          10987654321098765432109876543210
8522                                                          xxxxxxxxxx111011xxxxx1xx011100xx
8523                                                          fmulx.  */
8524                                                       return 290;
8525                                                     }
8526                                                   else
8527                                                     {
8528                                                       /* 33222222222211111111110000000000
8529                                                          10987654321098765432109876543210
8530                                                          xxxxxxxxxx111011xxxxx1xx011101xx
8531                                                          fmul.  */
8532                                                       return 339;
8533                                                     }
8534                                                 }
8535                                             }
8536                                         }
8537                                       else
8538                                         {
8539                                           if (((word >> 14) & 0x1) == 0)
8540                                             {
8541                                               if (((word >> 15) & 0x1) == 0)
8542                                                 {
8543                                                   if (((word >> 29) & 0x1) == 0)
8544                                                     {
8545                                                       /* 33222222222211111111110000000000
8546                                                          10987654321098765432109876543210
8547                                                          xxxxxxxxxx111100xxxxx1xx011100xx
8548                                                          cmge.  */
8549                                                       return 267;
8550                                                     }
8551                                                   else
8552                                                     {
8553                                                       /* 33222222222211111111110000000000
8554                                                          10987654321098765432109876543210
8555                                                          xxxxxxxxxx111100xxxxx1xx011101xx
8556                                                          cmhs.  */
8557                                                       return 319;
8558                                                     }
8559                                                 }
8560                                               else
8561                                                 {
8562                                                   /* 33222222222211111111110000000000
8563                                                      10987654321098765432109876543210
8564                                                      xxxxxxxxxx111101xxxxx1xx01110xxx
8565                                                      addp.  */
8566                                                   return 283;
8567                                                 }
8568                                             }
8569                                           else
8570                                             {
8571                                               if (((word >> 15) & 0x1) == 0)
8572                                                 {
8573                                                   if (((word >> 29) & 0x1) == 0)
8574                                                     {
8575                                                       /* 33222222222211111111110000000000
8576                                                          10987654321098765432109876543210
8577                                                          xxxxxxxxxx111110xxxxx1xx011100xx
8578                                                          saba.  */
8579                                                       return 275;
8580                                                     }
8581                                                   else
8582                                                     {
8583                                                       /* 33222222222211111111110000000000
8584                                                          10987654321098765432109876543210
8585                                                          xxxxxxxxxx111110xxxxx1xx011101xx
8586                                                          uaba.  */
8587                                                       return 327;
8588                                                     }
8589                                                 }
8590                                               else
8591                                                 {
8592                                                   if (((word >> 23) & 0x1) == 0)
8593                                                     {
8594                                                       if (((word >> 29) & 0x1) == 0)
8595                                                         {
8596                                                           /* 33222222222211111111110000000000
8597                                                              10987654321098765432109876543210
8598                                                              xxxxxxxxxx111111xxxxx1x0011100xx
8599                                                              frecps.  */
8600                                                           return 296;
8601                                                         }
8602                                                       else
8603                                                         {
8604                                                           /* 33222222222211111111110000000000
8605                                                              10987654321098765432109876543210
8606                                                              xxxxxxxxxx111111xxxxx1x0011101xx
8607                                                              fdiv.  */
8608                                                           return 347;
8609                                                         }
8610                                                     }
8611                                                   else
8612                                                     {
8613                                                       /* 33222222222211111111110000000000
8614                                                          10987654321098765432109876543210
8615                                                          xxxxxxxxxx111111xxxxx1x101110xxx
8616                                                          frsqrts.  */
8617                                                       return 308;
8618                                                     }
8619                                                 }
8620                                             }
8621                                         }
8622                                     }
8623                                 }
8624                               else
8625                                 {
8626                                   if (((word >> 29) & 0x1) == 0)
8627                                     {
8628                                       if (((word >> 30) & 0x1) == 0)
8629                                         {
8630                                           /* 33222222222211111111110000000000
8631                                              10987654321098765432109876543210
8632                                              xxxxxxxxxx11xxxxxxxxx1xx0111100x
8633                                              fcsel.  */
8634                                           return 815;
8635                                         }
8636                                       else
8637                                         {
8638                                           if (((word >> 12) & 0x1) == 0)
8639                                             {
8640                                               if (((word >> 13) & 0x1) == 0)
8641                                                 {
8642                                                   if (((word >> 14) & 0x1) == 0)
8643                                                     {
8644                                                       if (((word >> 15) & 0x1) == 0)
8645                                                         {
8646                                                           /* 33222222222211111111110000000000
8647                                                              10987654321098765432109876543210
8648                                                              xxxxxxxxxx110000xxxxx1xx0111101x
8649                                                              sqadd.  */
8650                                                           return 539;
8651                                                         }
8652                                                       else
8653                                                         {
8654                                                           /* 33222222222211111111110000000000
8655                                                              10987654321098765432109876543210
8656                                                              xxxxxxxxxx110001xxxxx1xx0111101x
8657                                                              cmtst.  */
8658                                                           return 557;
8659                                                         }
8660                                                     }
8661                                                   else
8662                                                     {
8663                                                       /* 33222222222211111111110000000000
8664                                                          10987654321098765432109876543210
8665                                                          xxxxxxxxxx11001xxxxxx1xx0111101x
8666                                                          sqshl.  */
8667                                                       return 541;
8668                                                     }
8669                                                 }
8670                                               else
8671                                                 {
8672                                                   /* 33222222222211111111110000000000
8673                                                      10987654321098765432109876543210
8674                                                      xxxxxxxxxx1101xxxxxxx1xx0111101x
8675                                                      sqsub.  */
8676                                                   return 540;
8677                                                 }
8678                                             }
8679                                           else
8680                                             {
8681                                               if (((word >> 13) & 0x1) == 0)
8682                                                 {
8683                                                   if (((word >> 15) & 0x1) == 0)
8684                                                     {
8685                                                       /* 33222222222211111111110000000000
8686                                                          10987654321098765432109876543210
8687                                                          xxxxxxxxxx1110x0xxxxx1xx0111101x
8688                                                          sqrshl.  */
8689                                                       return 542;
8690                                                     }
8691                                                   else
8692                                                     {
8693                                                       /* 33222222222211111111110000000000
8694                                                          10987654321098765432109876543210
8695                                                          xxxxxxxxxx1110x1xxxxx1xx0111101x
8696                                                          fmulx.  */
8697                                                       return 544;
8698                                                     }
8699                                                 }
8700                                               else
8701                                                 {
8702                                                   if (((word >> 14) & 0x1) == 0)
8703                                                     {
8704                                                       /* 33222222222211111111110000000000
8705                                                          10987654321098765432109876543210
8706                                                          xxxxxxxxxx11110xxxxxx1xx0111101x
8707                                                          cmge.  */
8708                                                       return 553;
8709                                                     }
8710                                                   else
8711                                                     {
8712                                                       if (((word >> 23) & 0x1) == 0)
8713                                                         {
8714                                                           /* 33222222222211111111110000000000
8715                                                              10987654321098765432109876543210
8716                                                              xxxxxxxxxx11111xxxxxx1x00111101x
8717                                                              frecps.  */
8718                                                           return 548;
8719                                                         }
8720                                                       else
8721                                                         {
8722                                                           /* 33222222222211111111110000000000
8723                                                              10987654321098765432109876543210
8724                                                              xxxxxxxxxx11111xxxxxx1x10111101x
8725                                                              frsqrts.  */
8726                                                           return 550;
8727                                                         }
8728                                                     }
8729                                                 }
8730                                             }
8731                                         }
8732                                     }
8733                                   else
8734                                     {
8735                                       if (((word >> 12) & 0x1) == 0)
8736                                         {
8737                                           if (((word >> 13) & 0x1) == 0)
8738                                             {
8739                                               if (((word >> 14) & 0x1) == 0)
8740                                                 {
8741                                                   if (((word >> 15) & 0x1) == 0)
8742                                                     {
8743                                                       /* 33222222222211111111110000000000
8744                                                          10987654321098765432109876543210
8745                                                          xxxxxxxxxx110000xxxxx1xx011111xx
8746                                                          uqadd.  */
8747                                                       return 558;
8748                                                     }
8749                                                   else
8750                                                     {
8751                                                       /* 33222222222211111111110000000000
8752                                                          10987654321098765432109876543210
8753                                                          xxxxxxxxxx110001xxxxx1xx011111xx
8754                                                          cmeq.  */
8755                                                       return 578;
8756                                                     }
8757                                                 }
8758                                               else
8759                                                 {
8760                                                   /* 33222222222211111111110000000000
8761                                                      10987654321098765432109876543210
8762                                                      xxxxxxxxxx11001xxxxxx1xx011111xx
8763                                                      uqshl.  */
8764                                                   return 560;
8765                                                 }
8766                                             }
8767                                           else
8768                                             {
8769                                               if (((word >> 14) & 0x1) == 0)
8770                                                 {
8771                                                   /* 33222222222211111111110000000000
8772                                                      10987654321098765432109876543210
8773                                                      xxxxxxxxxx11010xxxxxx1xx011111xx
8774                                                      uqsub.  */
8775                                                   return 559;
8776                                                 }
8777                                               else
8778                                                 {
8779                                                   if (((word >> 23) & 0x1) == 0)
8780                                                     {
8781                                                       /* 33222222222211111111110000000000
8782                                                          10987654321098765432109876543210
8783                                                          xxxxxxxxxx11011xxxxxx1x0011111xx
8784                                                          facge.  */
8785                                                       return 565;
8786                                                     }
8787                                                   else
8788                                                     {
8789                                                       /* 33222222222211111111110000000000
8790                                                          10987654321098765432109876543210
8791                                                          xxxxxxxxxx11011xxxxxx1x1011111xx
8792                                                          facgt.  */
8793                                                       return 571;
8794                                                     }
8795                                                 }
8796                                             }
8797                                         }
8798                                       else
8799                                         {
8800                                           if (((word >> 13) & 0x1) == 0)
8801                                             {
8802                                               /* 33222222222211111111110000000000
8803                                                  10987654321098765432109876543210
8804                                                  xxxxxxxxxx1110xxxxxxx1xx011111xx
8805                                                  uqrshl.  */
8806                                               return 561;
8807                                             }
8808                                           else
8809                                             {
8810                                               /* 33222222222211111111110000000000
8811                                                  10987654321098765432109876543210
8812                                                  xxxxxxxxxx1111xxxxxxx1xx011111xx
8813                                                  cmhs.  */
8814                                               return 574;
8815                                             }
8816                                         }
8817                                     }
8818                                 }
8819                             }
8820                         }
8821                     }
8822                 }
8823               else
8824                 {
8825                   if (((word >> 15) & 0x1) == 0)
8826                     {
8827                       if (((word >> 28) & 0x1) == 0)
8828                         {
8829                           if (((word >> 10) & 0x1) == 0)
8830                             {
8831                               if (((word >> 12) & 0x1) == 0)
8832                                 {
8833                                   if (((word >> 13) & 0x1) == 0)
8834                                     {
8835                                       if (((word >> 14) & 0x1) == 0)
8836                                         {
8837                                           /* 33222222222211111111110000000000
8838                                              10987654321098765432109876543210
8839                                              xxxxxxxxxx0x0000xxxxxxxx11110xxx
8840                                              mla.  */
8841                                           return 117;
8842                                         }
8843                                       else
8844                                         {
8845                                           /* 33222222222211111111110000000000
8846                                              10987654321098765432109876543210
8847                                              xxxxxxxxxx0x0010xxxxxxxx11110xxx
8848                                              mls.  */
8849                                           return 120;
8850                                         }
8851                                     }
8852                                   else
8853                                     {
8854                                       if (((word >> 14) & 0x1) == 0)
8855                                         {
8856                                           if (((word >> 29) & 0x1) == 0)
8857                                             {
8858                                               if (((word >> 30) & 0x1) == 0)
8859                                                 {
8860                                                   /* 33222222222211111111110000000000
8861                                                      10987654321098765432109876543210
8862                                                      xxxxxxxxxx0x0100xxxxxxxx1111000x
8863                                                      smlal.  */
8864                                                   return 96;
8865                                                 }
8866                                               else
8867                                                 {
8868                                                   /* 33222222222211111111110000000000
8869                                                      10987654321098765432109876543210
8870                                                      xxxxxxxxxx0x0100xxxxxxxx1111001x
8871                                                      smlal2.  */
8872                                                   return 97;
8873                                                 }
8874                                             }
8875                                           else
8876                                             {
8877                                               if (((word >> 30) & 0x1) == 0)
8878                                                 {
8879                                                   /* 33222222222211111111110000000000
8880                                                      10987654321098765432109876543210
8881                                                      xxxxxxxxxx0x0100xxxxxxxx1111010x
8882                                                      umlal.  */
8883                                                   return 118;
8884                                                 }
8885                                               else
8886                                                 {
8887                                                   /* 33222222222211111111110000000000
8888                                                      10987654321098765432109876543210
8889                                                      xxxxxxxxxx0x0100xxxxxxxx1111011x
8890                                                      umlal2.  */
8891                                                   return 119;
8892                                                 }
8893                                             }
8894                                         }
8895                                       else
8896                                         {
8897                                           if (((word >> 29) & 0x1) == 0)
8898                                             {
8899                                               if (((word >> 30) & 0x1) == 0)
8900                                                 {
8901                                                   /* 33222222222211111111110000000000
8902                                                      10987654321098765432109876543210
8903                                                      xxxxxxxxxx0x0110xxxxxxxx1111000x
8904                                                      smlsl.  */
8905                                                   return 100;
8906                                                 }
8907                                               else
8908                                                 {
8909                                                   /* 33222222222211111111110000000000
8910                                                      10987654321098765432109876543210
8911                                                      xxxxxxxxxx0x0110xxxxxxxx1111001x
8912                                                      smlsl2.  */
8913                                                   return 101;
8914                                                 }
8915                                             }
8916                                           else
8917                                             {
8918                                               if (((word >> 30) & 0x1) == 0)
8919                                                 {
8920                                                   /* 33222222222211111111110000000000
8921                                                      10987654321098765432109876543210
8922                                                      xxxxxxxxxx0x0110xxxxxxxx1111010x
8923                                                      umlsl.  */
8924                                                   return 121;
8925                                                 }
8926                                               else
8927                                                 {
8928                                                   /* 33222222222211111111110000000000
8929                                                      10987654321098765432109876543210
8930                                                      xxxxxxxxxx0x0110xxxxxxxx1111011x
8931                                                      umlsl2.  */
8932                                                   return 122;
8933                                                 }
8934                                             }
8935                                         }
8936                                     }
8937                                 }
8938                               else
8939                                 {
8940                                   if (((word >> 13) & 0x1) == 0)
8941                                     {
8942                                       if (((word >> 14) & 0x1) == 0)
8943                                         {
8944                                           if (((word >> 23) & 0x1) == 0)
8945                                             {
8946                                               /* 33222222222211111111110000000000
8947                                                  10987654321098765432109876543210
8948                                                  xxxxxxxxxx0x1000xxxxxxx011110xxx
8949                                                  fmla.  */
8950                                               return 112;
8951                                             }
8952                                           else
8953                                             {
8954                                               /* 33222222222211111111110000000000
8955                                                  10987654321098765432109876543210
8956                                                  xxxxxxxxxx0x1000xxxxxxx111110xxx
8957                                                  fmla.  */
8958                                               return 111;
8959                                             }
8960                                         }
8961                                       else
8962                                         {
8963                                           if (((word >> 23) & 0x1) == 0)
8964                                             {
8965                                               /* 33222222222211111111110000000000
8966                                                  10987654321098765432109876543210
8967                                                  xxxxxxxxxx0x1010xxxxxxx011110xxx
8968                                                  fmls.  */
8969                                               return 114;
8970                                             }
8971                                           else
8972                                             {
8973                                               /* 33222222222211111111110000000000
8974                                                  10987654321098765432109876543210
8975                                                  xxxxxxxxxx0x1010xxxxxxx111110xxx
8976                                                  fmls.  */
8977                                               return 113;
8978                                             }
8979                                         }
8980                                     }
8981                                   else
8982                                     {
8983                                       if (((word >> 14) & 0x1) == 0)
8984                                         {
8985                                           if (((word >> 30) & 0x1) == 0)
8986                                             {
8987                                               /* 33222222222211111111110000000000
8988                                                  10987654321098765432109876543210
8989                                                  xxxxxxxxxx0x1100xxxxxxxx11110x0x
8990                                                  sqdmlal.  */
8991                                               return 98;
8992                                             }
8993                                           else
8994                                             {
8995                                               /* 33222222222211111111110000000000
8996                                                  10987654321098765432109876543210
8997                                                  xxxxxxxxxx0x1100xxxxxxxx11110x1x
8998                                                  sqdmlal2.  */
8999                                               return 99;
9000                                             }
9001                                         }
9002                                       else
9003                                         {
9004                                           if (((word >> 30) & 0x1) == 0)
9005                                             {
9006                                               /* 33222222222211111111110000000000
9007                                                  10987654321098765432109876543210
9008                                                  xxxxxxxxxx0x1110xxxxxxxx11110x0x
9009                                                  sqdmlsl.  */
9010                                               return 102;
9011                                             }
9012                                           else
9013                                             {
9014                                               /* 33222222222211111111110000000000
9015                                                  10987654321098765432109876543210
9016                                                  xxxxxxxxxx0x1110xxxxxxxx11110x1x
9017                                                  sqdmlsl2.  */
9018                                               return 103;
9019                                             }
9020                                         }
9021                                     }
9022                                 }
9023                             }
9024                           else
9025                             {
9026                               if (((word >> 12) & 0x1) == 0)
9027                                 {
9028                                   if (((word >> 29) & 0x1) == 0)
9029                                     {
9030                                       /* 33222222222211111111110000000000
9031                                          10987654321098765432109876543210
9032                                          xxxxxxxxxx1x0xx0xxxxxxxx111100xx
9033                                          movi.  */
9034                                       return 130;
9035                                     }
9036                                   else
9037                                     {
9038                                       /* 33222222222211111111110000000000
9039                                          10987654321098765432109876543210
9040                                          xxxxxxxxxx1x0xx0xxxxxxxx111101xx
9041                                          mvni.  */
9042                                       return 138;
9043                                     }
9044                                 }
9045                               else
9046                                 {
9047                                   if (((word >> 29) & 0x1) == 0)
9048                                     {
9049                                       /* 33222222222211111111110000000000
9050                                          10987654321098765432109876543210
9051                                          xxxxxxxxxx1x1xx0xxxxxxxx111100xx
9052                                          orr.  */
9053                                       return 131;
9054                                     }
9055                                   else
9056                                     {
9057                                       /* 33222222222211111111110000000000
9058                                          10987654321098765432109876543210
9059                                          xxxxxxxxxx1x1xx0xxxxxxxx111101xx
9060                                          bic.  */
9061                                       return 139;
9062                                     }
9063                                 }
9064                             }
9065                         }
9066                       else
9067                         {
9068                           if (((word >> 29) & 0x1) == 0)
9069                             {
9070                               if (((word >> 30) & 0x1) == 0)
9071                                 {
9072                                   if (((word >> 21) & 0x1) == 0)
9073                                     {
9074                                       /* 33222222222211111111110000000000
9075                                          10987654321098765432109876543210
9076                                          xxxxxxxxxxxxxxx0xxxxx0xx1111100x
9077                                          fmadd.  */
9078                                       return 805;
9079                                     }
9080                                   else
9081                                     {
9082                                       /* 33222222222211111111110000000000
9083                                          10987654321098765432109876543210
9084                                          xxxxxxxxxxxxxxx0xxxxx1xx1111100x
9085                                          fnmadd.  */
9086                                       return 809;
9087                                     }
9088                                 }
9089                               else
9090                                 {
9091                                   if (((word >> 10) & 0x1) == 0)
9092                                     {
9093                                       if (((word >> 13) & 0x1) == 0)
9094                                         {
9095                                           if (((word >> 14) & 0x1) == 0)
9096                                             {
9097                                               if (((word >> 23) & 0x1) == 0)
9098                                                 {
9099                                                   /* 33222222222211111111110000000000
9100                                                      10987654321098765432109876543210
9101                                                      xxxxxxxxxx0xx000xxxxxxx01111101x
9102                                                      fmla.  */
9103                                                   return 422;
9104                                                 }
9105                                               else
9106                                                 {
9107                                                   /* 33222222222211111111110000000000
9108                                                      10987654321098765432109876543210
9109                                                      xxxxxxxxxx0xx000xxxxxxx11111101x
9110                                                      fmla.  */
9111                                                   return 421;
9112                                                 }
9113                                             }
9114                                           else
9115                                             {
9116                                               if (((word >> 23) & 0x1) == 0)
9117                                                 {
9118                                                   /* 33222222222211111111110000000000
9119                                                      10987654321098765432109876543210
9120                                                      xxxxxxxxxx0xx010xxxxxxx01111101x
9121                                                      fmls.  */
9122                                                   return 424;
9123                                                 }
9124                                               else
9125                                                 {
9126                                                   /* 33222222222211111111110000000000
9127                                                      10987654321098765432109876543210
9128                                                      xxxxxxxxxx0xx010xxxxxxx11111101x
9129                                                      fmls.  */
9130                                                   return 423;
9131                                                 }
9132                                             }
9133                                         }
9134                                       else
9135                                         {
9136                                           if (((word >> 14) & 0x1) == 0)
9137                                             {
9138                                               /* 33222222222211111111110000000000
9139                                                  10987654321098765432109876543210
9140                                                  xxxxxxxxxx0xx100xxxxxxxx1111101x
9141                                                  sqdmlal.  */
9142                                               return 416;
9143                                             }
9144                                           else
9145                                             {
9146                                               /* 33222222222211111111110000000000
9147                                                  10987654321098765432109876543210
9148                                                  xxxxxxxxxx0xx110xxxxxxxx1111101x
9149                                                  sqdmlsl.  */
9150                                               return 417;
9151                                             }
9152                                         }
9153                                     }
9154                                   else
9155                                     {
9156                                       if (((word >> 12) & 0x1) == 0)
9157                                         {
9158                                           if (((word >> 13) & 0x1) == 0)
9159                                             {
9160                                               /* 33222222222211111111110000000000
9161                                                  10987654321098765432109876543210
9162                                                  xxxxxxxxxx1x00x0xxxxxxxx1111101x
9163                                                  sshr.  */
9164                                               return 581;
9165                                             }
9166                                           else
9167                                             {
9168                                               /* 33222222222211111111110000000000
9169                                                  10987654321098765432109876543210
9170                                                  xxxxxxxxxx1x01x0xxxxxxxx1111101x
9171                                                  srshr.  */
9172                                               return 583;
9173                                             }
9174                                         }
9175                                       else
9176                                         {
9177                                           if (((word >> 13) & 0x1) == 0)
9178                                             {
9179                                               if (((word >> 14) & 0x1) == 0)
9180                                                 {
9181                                                   /* 33222222222211111111110000000000
9182                                                      10987654321098765432109876543210
9183                                                      xxxxxxxxxx1x1000xxxxxxxx1111101x
9184                                                      ssra.  */
9185                                                   return 582;
9186                                                 }
9187                                               else
9188                                                 {
9189                                                   /* 33222222222211111111110000000000
9190                                                      10987654321098765432109876543210
9191                                                      xxxxxxxxxx1x1010xxxxxxxx1111101x
9192                                                      shl.  */
9193                                                   return 585;
9194                                                 }
9195                                             }
9196                                           else
9197                                             {
9198                                               if (((word >> 14) & 0x1) == 0)
9199                                                 {
9200                                                   /* 33222222222211111111110000000000
9201                                                      10987654321098765432109876543210
9202                                                      xxxxxxxxxx1x1100xxxxxxxx1111101x
9203                                                      srsra.  */
9204                                                   return 584;
9205                                                 }
9206                                               else
9207                                                 {
9208                                                   /* 33222222222211111111110000000000
9209                                                      10987654321098765432109876543210
9210                                                      xxxxxxxxxx1x1110xxxxxxxx1111101x
9211                                                      sqshl.  */
9212                                                   return 586;
9213                                                 }
9214                                             }
9215                                         }
9216                                     }
9217                                 }
9218                             }
9219                           else
9220                             {
9221                               if (((word >> 12) & 0x1) == 0)
9222                                 {
9223                                   if (((word >> 13) & 0x1) == 0)
9224                                     {
9225                                       if (((word >> 14) & 0x1) == 0)
9226                                         {
9227                                           /* 33222222222211111111110000000000
9228                                              10987654321098765432109876543210
9229                                              xxxxxxxxxxxx0000xxxxxxxx111111xx
9230                                              ushr.  */
9231                                           return 593;
9232                                         }
9233                                       else
9234                                         {
9235                                           /* 33222222222211111111110000000000
9236                                              10987654321098765432109876543210
9237                                              xxxxxxxxxxxx0010xxxxxxxx111111xx
9238                                              sri.  */
9239                                           return 597;
9240                                         }
9241                                     }
9242                                   else
9243                                     {
9244                                       if (((word >> 14) & 0x1) == 0)
9245                                         {
9246                                           /* 33222222222211111111110000000000
9247                                              10987654321098765432109876543210
9248                                              xxxxxxxxxxxx0100xxxxxxxx111111xx
9249                                              urshr.  */
9250                                           return 595;
9251                                         }
9252                                       else
9253                                         {
9254                                           /* 33222222222211111111110000000000
9255                                              10987654321098765432109876543210
9256                                              xxxxxxxxxxxx0110xxxxxxxx111111xx
9257                                              sqshlu.  */
9258                                           return 599;
9259                                         }
9260                                     }
9261                                 }
9262                               else
9263                                 {
9264                                   if (((word >> 13) & 0x1) == 0)
9265                                     {
9266                                       if (((word >> 14) & 0x1) == 0)
9267                                         {
9268                                           /* 33222222222211111111110000000000
9269                                              10987654321098765432109876543210
9270                                              xxxxxxxxxxxx1000xxxxxxxx111111xx
9271                                              usra.  */
9272                                           return 594;
9273                                         }
9274                                       else
9275                                         {
9276                                           /* 33222222222211111111110000000000
9277                                              10987654321098765432109876543210
9278                                              xxxxxxxxxxxx1010xxxxxxxx111111xx
9279                                              sli.  */
9280                                           return 598;
9281                                         }
9282                                     }
9283                                   else
9284                                     {
9285                                       if (((word >> 14) & 0x1) == 0)
9286                                         {
9287                                           /* 33222222222211111111110000000000
9288                                              10987654321098765432109876543210
9289                                              xxxxxxxxxxxx1100xxxxxxxx111111xx
9290                                              ursra.  */
9291                                           return 596;
9292                                         }
9293                                       else
9294                                         {
9295                                           /* 33222222222211111111110000000000
9296                                              10987654321098765432109876543210
9297                                              xxxxxxxxxxxx1110xxxxxxxx111111xx
9298                                              uqshl.  */
9299                                           return 600;
9300                                         }
9301                                     }
9302                                 }
9303                             }
9304                         }
9305                     }
9306                   else
9307                     {
9308                       if (((word >> 28) & 0x1) == 0)
9309                         {
9310                           if (((word >> 10) & 0x1) == 0)
9311                             {
9312                               if (((word >> 12) & 0x1) == 0)
9313                                 {
9314                                   if (((word >> 13) & 0x1) == 0)
9315                                     {
9316                                       if (((word >> 14) & 0x1) == 0)
9317                                         {
9318                                           /* 33222222222211111111110000000000
9319                                              10987654321098765432109876543210
9320                                              xxxxxxxxxx0x0001xxxxxxxx11110xxx
9321                                              mul.  */
9322                                           return 104;
9323                                         }
9324                                       else
9325                                         {
9326                                           /* 33222222222211111111110000000000
9327                                              10987654321098765432109876543210
9328                                              xxxxxxxxxx0x0011xxxxxxxx11110xxx
9329                                              sqdmulh.  */
9330                                           return 109;
9331                                         }
9332                                     }
9333                                   else
9334                                     {
9335                                       if (((word >> 29) & 0x1) == 0)
9336                                         {
9337                                           if (((word >> 30) & 0x1) == 0)
9338                                             {
9339                                               /* 33222222222211111111110000000000
9340                                                  10987654321098765432109876543210
9341                                                  xxxxxxxxxx0x01x1xxxxxxxx1111000x
9342                                                  smull.  */
9343                                               return 105;
9344                                             }
9345                                           else
9346                                             {
9347                                               /* 33222222222211111111110000000000
9348                                                  10987654321098765432109876543210
9349                                                  xxxxxxxxxx0x01x1xxxxxxxx1111001x
9350                                                  smull2.  */
9351                                               return 106;
9352                                             }
9353                                         }
9354                                       else
9355                                         {
9356                                           if (((word >> 30) & 0x1) == 0)
9357                                             {
9358                                               /* 33222222222211111111110000000000
9359                                                  10987654321098765432109876543210
9360                                                  xxxxxxxxxx0x01x1xxxxxxxx1111010x
9361                                                  umull.  */
9362                                               return 123;
9363                                             }
9364                                           else
9365                                             {
9366                                               /* 33222222222211111111110000000000
9367                                                  10987654321098765432109876543210
9368                                                  xxxxxxxxxx0x01x1xxxxxxxx1111011x
9369                                                  umull2.  */
9370                                               return 124;
9371                                             }
9372                                         }
9373                                     }
9374                                 }
9375                               else
9376                                 {
9377                                   if (((word >> 13) & 0x1) == 0)
9378                                     {
9379                                       if (((word >> 14) & 0x1) == 0)
9380                                         {
9381                                           if (((word >> 23) & 0x1) == 0)
9382                                             {
9383                                               if (((word >> 29) & 0x1) == 0)
9384                                                 {
9385                                                   /* 33222222222211111111110000000000
9386                                                      10987654321098765432109876543210
9387                                                      xxxxxxxxxx0x1001xxxxxxx0111100xx
9388                                                      fmul.  */
9389                                                   return 116;
9390                                                 }
9391                                               else
9392                                                 {
9393                                                   /* 33222222222211111111110000000000
9394                                                      10987654321098765432109876543210
9395                                                      xxxxxxxxxx0x1001xxxxxxx0111101xx
9396                                                      fmulx.  */
9397                                                   return 126;
9398                                                 }
9399                                             }
9400                                           else
9401                                             {
9402                                               if (((word >> 29) & 0x1) == 0)
9403                                                 {
9404                                                   /* 33222222222211111111110000000000
9405                                                      10987654321098765432109876543210
9406                                                      xxxxxxxxxx0x1001xxxxxxx1111100xx
9407                                                      fmul.  */
9408                                                   return 115;
9409                                                 }
9410                                               else
9411                                                 {
9412                                                   /* 33222222222211111111110000000000
9413                                                      10987654321098765432109876543210
9414                                                      xxxxxxxxxx0x1001xxxxxxx1111101xx
9415                                                      fmulx.  */
9416                                                   return 125;
9417                                                 }
9418                                             }
9419                                         }
9420                                       else
9421                                         {
9422                                           if (((word >> 29) & 0x1) == 0)
9423                                             {
9424                                               /* 33222222222211111111110000000000
9425                                                  10987654321098765432109876543210
9426                                                  xxxxxxxxxx0x1011xxxxxxxx111100xx
9427                                                  sqrdmulh.  */
9428                                               return 110;
9429                                             }
9430                                           else
9431                                             {
9432                                               /* 33222222222211111111110000000000
9433                                                  10987654321098765432109876543210
9434                                                  xxxxxxxxxx0x1011xxxxxxxx111101xx
9435                                                  sqrdmlah.  */
9436                                               return 127;
9437                                             }
9438                                         }
9439                                     }
9440                                   else
9441                                     {
9442                                       if (((word >> 14) & 0x1) == 0)
9443                                         {
9444                                           if (((word >> 30) & 0x1) == 0)
9445                                             {
9446                                               /* 33222222222211111111110000000000
9447                                                  10987654321098765432109876543210
9448                                                  xxxxxxxxxx0x1101xxxxxxxx11110x0x
9449                                                  sqdmull.  */
9450                                               return 107;
9451                                             }
9452                                           else
9453                                             {
9454                                               /* 33222222222211111111110000000000
9455                                                  10987654321098765432109876543210
9456                                                  xxxxxxxxxx0x1101xxxxxxxx11110x1x
9457                                                  sqdmull2.  */
9458                                               return 108;
9459                                             }
9460                                         }
9461                                       else
9462                                         {
9463                                           /* 33222222222211111111110000000000
9464                                              10987654321098765432109876543210
9465                                              xxxxxxxxxx0x1111xxxxxxxx11110xxx
9466                                              sqrdmlsh.  */
9467                                           return 128;
9468                                         }
9469                                     }
9470                                 }
9471                             }
9472                           else
9473                             {
9474                               if (((word >> 11) & 0x1) == 0)
9475                                 {
9476                                   if (((word >> 14) & 0x1) == 0)
9477                                     {
9478                                       if (((word >> 12) & 0x1) == 0)
9479                                         {
9480                                           if (((word >> 29) & 0x1) == 0)
9481                                             {
9482                                               /* 33222222222211111111110000000000
9483                                                  10987654321098765432109876543210
9484                                                  xxxxxxxxxx100x01xxxxxxxx111100xx
9485                                                  movi.  */
9486                                               return 132;
9487                                             }
9488                                           else
9489                                             {
9490                                               /* 33222222222211111111110000000000
9491                                                  10987654321098765432109876543210
9492                                                  xxxxxxxxxx100x01xxxxxxxx111101xx
9493                                                  mvni.  */
9494                                               return 140;
9495                                             }
9496                                         }
9497                                       else
9498                                         {
9499                                           if (((word >> 29) & 0x1) == 0)
9500                                             {
9501                                               /* 33222222222211111111110000000000
9502                                                  10987654321098765432109876543210
9503                                                  xxxxxxxxxx101x01xxxxxxxx111100xx
9504                                                  orr.  */
9505                                               return 133;
9506                                             }
9507                                           else
9508                                             {
9509                                               /* 33222222222211111111110000000000
9510                                                  10987654321098765432109876543210
9511                                                  xxxxxxxxxx101x01xxxxxxxx111101xx
9512                                                  bic.  */
9513                                               return 141;
9514                                             }
9515                                         }
9516                                     }
9517                                   else
9518                                     {
9519                                       if (((word >> 13) & 0x1) == 0)
9520                                         {
9521                                           if (((word >> 29) & 0x1) == 0)
9522                                             {
9523                                               /* 33222222222211111111110000000000
9524                                                  10987654321098765432109876543210
9525                                                  xxxxxxxxxx10x011xxxxxxxx111100xx
9526                                                  movi.  */
9527                                               return 134;
9528                                             }
9529                                           else
9530                                             {
9531                                               /* 33222222222211111111110000000000
9532                                                  10987654321098765432109876543210
9533                                                  xxxxxxxxxx10x011xxxxxxxx111101xx
9534                                                  mvni.  */
9535                                               return 142;
9536                                             }
9537                                         }
9538                                       else
9539                                         {
9540                                           if (((word >> 12) & 0x1) == 0)
9541                                             {
9542                                               if (((word >> 29) & 0x1) == 0)
9543                                                 {
9544                                                   /* 33222222222211111111110000000000
9545                                                      10987654321098765432109876543210
9546                                                      xxxxxxxxxx100111xxxxxxxx111100xx
9547                                                      movi.  */
9548                                                   return 135;
9549                                                 }
9550                                               else
9551                                                 {
9552                                                   /* 33222222222211111111110000000000
9553                                                      10987654321098765432109876543210
9554                                                      xxxxxxxxxx100111xxxxxxxx111101xx
9555                                                      movi.  */
9556                                                   return 143;
9557                                                 }
9558                                             }
9559                                           else
9560                                             {
9561                                               if (((word >> 29) & 0x1) == 0)
9562                                                 {
9563                                                   /* 33222222222211111111110000000000
9564                                                      10987654321098765432109876543210
9565                                                      xxxxxxxxxx101111xxxxxxxx111100xx
9566                                                      fmov.  */
9567                                                   return 136;
9568                                                 }
9569                                               else
9570                                                 {
9571                                                   /* 33222222222211111111110000000000
9572                                                      10987654321098765432109876543210
9573                                                      xxxxxxxxxx101111xxxxxxxx111101xx
9574                                                      fmov.  */
9575                                                   return 145;
9576                                                 }
9577                                             }
9578                                         }
9579                                     }
9580                                 }
9581                               else
9582                                 {
9583                                   if (((word >> 12) & 0x1) == 0)
9584                                     {
9585                                       if (((word >> 29) & 0x1) == 0)
9586                                         {
9587                                           if (((word >> 30) & 0x1) == 0)
9588                                             {
9589                                               /* 33222222222211111111110000000000
9590                                                  10987654321098765432109876543210
9591                                                  xxxxxxxxxx110xx1xxxxxxxx1111000x
9592                                                  rshrn.  */
9593                                               return 373;
9594                                             }
9595                                           else
9596                                             {
9597                                               /* 33222222222211111111110000000000
9598                                                  10987654321098765432109876543210
9599                                                  xxxxxxxxxx110xx1xxxxxxxx1111001x
9600                                                  rshrn2.  */
9601                                               return 374;
9602                                             }
9603                                         }
9604                                       else
9605                                         {
9606                                           if (((word >> 30) & 0x1) == 0)
9607                                             {
9608                                               /* 33222222222211111111110000000000
9609                                                  10987654321098765432109876543210
9610                                                  xxxxxxxxxx110xx1xxxxxxxx1111010x
9611                                                  sqrshrun.  */
9612                                               return 397;
9613                                             }
9614                                           else
9615                                             {
9616                                               /* 33222222222211111111110000000000
9617                                                  10987654321098765432109876543210
9618                                                  xxxxxxxxxx110xx1xxxxxxxx1111011x
9619                                                  sqrshrun2.  */
9620                                               return 398;
9621                                             }
9622                                         }
9623                                     }
9624                                   else
9625                                     {
9626                                       if (((word >> 13) & 0x1) == 0)
9627                                         {
9628                                           if (((word >> 29) & 0x1) == 0)
9629                                             {
9630                                               if (((word >> 30) & 0x1) == 0)
9631                                                 {
9632                                                   /* 33222222222211111111110000000000
9633                                                      10987654321098765432109876543210
9634                                                      xxxxxxxxxx1110x1xxxxxxxx1111000x
9635                                                      sqrshrn.  */
9636                                                   return 377;
9637                                                 }
9638                                               else
9639                                                 {
9640                                                   /* 33222222222211111111110000000000
9641                                                      10987654321098765432109876543210
9642                                                      xxxxxxxxxx1110x1xxxxxxxx1111001x
9643                                                      sqrshrn2.  */
9644                                                   return 378;
9645                                                 }
9646                                             }
9647                                           else
9648                                             {
9649                                               if (((word >> 30) & 0x1) == 0)
9650                                                 {
9651                                                   /* 33222222222211111111110000000000
9652                                                      10987654321098765432109876543210
9653                                                      xxxxxxxxxx1110x1xxxxxxxx1111010x
9654                                                      uqrshrn.  */
9655                                                   return 401;
9656                                                 }
9657                                               else
9658                                                 {
9659                                                   /* 33222222222211111111110000000000
9660                                                      10987654321098765432109876543210
9661                                                      xxxxxxxxxx1110x1xxxxxxxx1111011x
9662                                                      uqrshrn2.  */
9663                                                   return 402;
9664                                                 }
9665                                             }
9666                                         }
9667                                       else
9668                                         {
9669                                           if (((word >> 29) & 0x1) == 0)
9670                                             {
9671                                               /* 33222222222211111111110000000000
9672                                                  10987654321098765432109876543210
9673                                                  xxxxxxxxxx1111x1xxxxxxxx111100xx
9674                                                  fmov.  */
9675                                               return 137;
9676                                             }
9677                                           else
9678                                             {
9679                                               /* 33222222222211111111110000000000
9680                                                  10987654321098765432109876543210
9681                                                  xxxxxxxxxx1111x1xxxxxxxx111101xx
9682                                                  fcvtzu.  */
9683                                               return 409;
9684                                             }
9685                                         }
9686                                     }
9687                                 }
9688                             }
9689                         }
9690                       else
9691                         {
9692                           if (((word >> 29) & 0x1) == 0)
9693                             {
9694                               if (((word >> 30) & 0x1) == 0)
9695                                 {
9696                                   if (((word >> 21) & 0x1) == 0)
9697                                     {
9698                                       /* 33222222222211111111110000000000
9699                                          10987654321098765432109876543210
9700                                          xxxxxxxxxxxxxxx1xxxxx0xx1111100x
9701                                          fmsub.  */
9702                                       return 807;
9703                                     }
9704                                   else
9705                                     {
9706                                       /* 33222222222211111111110000000000
9707                                          10987654321098765432109876543210
9708                                          xxxxxxxxxxxxxxx1xxxxx1xx1111100x
9709                                          fnmsub.  */
9710                                       return 811;
9711                                     }
9712                                 }
9713                               else
9714                                 {
9715                                   if (((word >> 10) & 0x1) == 0)
9716                                     {
9717                                       if (((word >> 12) & 0x1) == 0)
9718                                         {
9719                                           /* 33222222222211111111110000000000
9720                                              10987654321098765432109876543210
9721                                              xxxxxxxxxx0x0xx1xxxxxxxx1111101x
9722                                              sqdmulh.  */
9723                                           return 419;
9724                                         }
9725                                       else
9726                                         {
9727                                           if (((word >> 13) & 0x1) == 0)
9728                                             {
9729                                               if (((word >> 14) & 0x1) == 0)
9730                                                 {
9731                                                   if (((word >> 23) & 0x1) == 0)
9732                                                     {
9733                                                       /* 33222222222211111111110000000000
9734                                                          10987654321098765432109876543210
9735                                                          xxxxxxxxxx0x1001xxxxxxx01111101x
9736                                                          fmul.  */
9737                                                       return 426;
9738                                                     }
9739                                                   else
9740                                                     {
9741                                                       /* 33222222222211111111110000000000
9742                                                          10987654321098765432109876543210
9743                                                          xxxxxxxxxx0x1001xxxxxxx11111101x
9744                                                          fmul.  */
9745                                                       return 425;
9746                                                     }
9747                                                 }
9748                                               else
9749                                                 {
9750                                                   /* 33222222222211111111110000000000
9751                                                      10987654321098765432109876543210
9752                                                      xxxxxxxxxx0x1011xxxxxxxx1111101x
9753                                                      sqrdmulh.  */
9754                                                   return 420;
9755                                                 }
9756                                             }
9757                                           else
9758                                             {
9759                                               /* 33222222222211111111110000000000
9760                                                  10987654321098765432109876543210
9761                                                  xxxxxxxxxx0x11x1xxxxxxxx1111101x
9762                                                  sqdmull.  */
9763                                               return 418;
9764                                             }
9765                                         }
9766                                     }
9767                                   else
9768                                     {
9769                                       if (((word >> 11) & 0x1) == 0)
9770                                         {
9771                                           if (((word >> 12) & 0x1) == 0)
9772                                             {
9773                                               /* 33222222222211111111110000000000
9774                                                  10987654321098765432109876543210
9775                                                  xxxxxxxxxx100xx1xxxxxxxx1111101x
9776                                                  scvtf.  */
9777                                               return 589;
9778                                             }
9779                                           else
9780                                             {
9781                                               /* 33222222222211111111110000000000
9782                                                  10987654321098765432109876543210
9783                                                  xxxxxxxxxx101xx1xxxxxxxx1111101x
9784                                                  sqshrn.  */
9785                                               return 587;
9786                                             }
9787                                         }
9788                                       else
9789                                         {
9790                                           if (((word >> 13) & 0x1) == 0)
9791                                             {
9792                                               /* 33222222222211111111110000000000
9793                                                  10987654321098765432109876543210
9794                                                  xxxxxxxxxx11x0x1xxxxxxxx1111101x
9795                                                  sqrshrn.  */
9796                                               return 588;
9797                                             }
9798                                           else
9799                                             {
9800                                               /* 33222222222211111111110000000000
9801                                                  10987654321098765432109876543210
9802                                                  xxxxxxxxxx11x1x1xxxxxxxx1111101x
9803                                                  fcvtzs.  */
9804                                               return 591;
9805                                             }
9806                                         }
9807                                     }
9808                                 }
9809                             }
9810                           else
9811                             {
9812                               if (((word >> 10) & 0x1) == 0)
9813                                 {
9814                                   if (((word >> 13) & 0x1) == 0)
9815                                     {
9816                                       if (((word >> 14) & 0x1) == 0)
9817                                         {
9818                                           if (((word >> 23) & 0x1) == 0)
9819                                             {
9820                                               /* 33222222222211111111110000000000
9821                                                  10987654321098765432109876543210
9822                                                  xxxxxxxxxx0xx001xxxxxxx0111111xx
9823                                                  fmulx.  */
9824                                               return 428;
9825                                             }
9826                                           else
9827                                             {
9828                                               /* 33222222222211111111110000000000
9829                                                  10987654321098765432109876543210
9830                                                  xxxxxxxxxx0xx001xxxxxxx1111111xx
9831                                                  fmulx.  */
9832                                               return 427;
9833                                             }
9834                                         }
9835                                       else
9836                                         {
9837                                           /* 33222222222211111111110000000000
9838                                              10987654321098765432109876543210
9839                                              xxxxxxxxxx0xx011xxxxxxxx111111xx
9840                                              sqrdmlah.  */
9841                                           return 429;
9842                                         }
9843                                     }
9844                                   else
9845                                     {
9846                                       /* 33222222222211111111110000000000
9847                                          10987654321098765432109876543210
9848                                          xxxxxxxxxx0xx1x1xxxxxxxx111111xx
9849                                          sqrdmlsh.  */
9850                                       return 430;
9851                                     }
9852                                 }
9853                               else
9854                                 {
9855                                   if (((word >> 11) & 0x1) == 0)
9856                                     {
9857                                       if (((word >> 12) & 0x1) == 0)
9858                                         {
9859                                           if (((word >> 13) & 0x1) == 0)
9860                                             {
9861                                               /* 33222222222211111111110000000000
9862                                                  10987654321098765432109876543210
9863                                                  xxxxxxxxxx1000x1xxxxxxxx111111xx
9864                                                  sqshrun.  */
9865                                               return 601;
9866                                             }
9867                                           else
9868                                             {
9869                                               /* 33222222222211111111110000000000
9870                                                  10987654321098765432109876543210
9871                                                  xxxxxxxxxx1001x1xxxxxxxx111111xx
9872                                                  ucvtf.  */
9873                                               return 605;
9874                                             }
9875                                         }
9876                                       else
9877                                         {
9878                                           /* 33222222222211111111110000000000
9879                                              10987654321098765432109876543210
9880                                              xxxxxxxxxx101xx1xxxxxxxx111111xx
9881                                              uqshrn.  */
9882                                           return 603;
9883                                         }
9884                                     }
9885                                   else
9886                                     {
9887                                       if (((word >> 12) & 0x1) == 0)
9888                                         {
9889                                           /* 33222222222211111111110000000000
9890                                              10987654321098765432109876543210
9891                                              xxxxxxxxxx110xx1xxxxxxxx111111xx
9892                                              sqrshrun.  */
9893                                           return 602;
9894                                         }
9895                                       else
9896                                         {
9897                                           if (((word >> 13) & 0x1) == 0)
9898                                             {
9899                                               /* 33222222222211111111110000000000
9900                                                  10987654321098765432109876543210
9901                                                  xxxxxxxxxx1110x1xxxxxxxx111111xx
9902                                                  uqrshrn.  */
9903                                               return 604;
9904                                             }
9905                                           else
9906                                             {
9907                                               /* 33222222222211111111110000000000
9908                                                  10987654321098765432109876543210
9909                                                  xxxxxxxxxx1111x1xxxxxxxx111111xx
9910                                                  fcvtzu.  */
9911                                               return 607;
9912                                             }
9913                                         }
9914                                     }
9915                                 }
9916                             }
9917                         }
9918                     }
9919                 }
9920             }
9921         }
9922     }
9923 }
9924
9925 /* Lookup opcode WORD in the opcode table.  N.B. all alias
9926    opcodes are ignored here.  */
9927
9928 const aarch64_opcode *
9929 aarch64_opcode_lookup (uint32_t word)
9930 {
9931   return aarch64_opcode_table + aarch64_opcode_lookup_1 (word);
9932 }
9933
9934 const aarch64_opcode *
9935 aarch64_find_next_opcode (const aarch64_opcode *opcode)
9936 {
9937   /* Use the index as the key to locate the next opcode.  */
9938   int key = opcode - aarch64_opcode_table;
9939   int value;
9940   switch (key)
9941     {
9942     case 901: value = 905; break;       /* stnp --> stp.  */
9943     case 905: return NULL;              /* stp --> NULL.  */
9944     case 899: value = 900; break;       /* stllrb --> stllrh.  */
9945     case 900: return NULL;              /* stllrh --> NULL.  */
9946     case 902: value = 906; break;       /* ldnp --> ldp.  */
9947     case 906: return NULL;              /* ldp --> NULL.  */
9948     case 1117: value = 1118; break;     /* msr --> hint.  */
9949     case 1118: value = 1127; break;     /* hint --> clrex.  */
9950     case 1127: value = 1128; break;     /* clrex --> dsb.  */
9951     case 1128: value = 1129; break;     /* dsb --> dmb.  */
9952     case 1129: value = 1130; break;     /* dmb --> isb.  */
9953     case 1130: value = 1131; break;     /* isb --> sys.  */
9954     case 1131: value = 1136; break;     /* sys --> msr.  */
9955     case 1136: return NULL;             /* msr --> NULL.  */
9956     case 1137: value = 1138; break;     /* sysl --> mrs.  */
9957     case 1138: return NULL;             /* mrs --> NULL.  */
9958     case 431: value = 432; break;       /* st4 --> st1.  */
9959     case 432: value = 433; break;       /* st1 --> st2.  */
9960     case 433: value = 434; break;       /* st2 --> st3.  */
9961     case 434: return NULL;              /* st3 --> NULL.  */
9962     case 439: value = 440; break;       /* st4 --> st1.  */
9963     case 440: value = 441; break;       /* st1 --> st2.  */
9964     case 441: value = 442; break;       /* st2 --> st3.  */
9965     case 442: return NULL;              /* st3 --> NULL.  */
9966     case 435: value = 436; break;       /* ld4 --> ld1.  */
9967     case 436: value = 437; break;       /* ld1 --> ld2.  */
9968     case 437: value = 438; break;       /* ld2 --> ld3.  */
9969     case 438: return NULL;              /* ld3 --> NULL.  */
9970     case 451: value = 453; break;       /* ld1 --> ld1r.  */
9971     case 453: return NULL;              /* ld1r --> NULL.  */
9972     case 455: value = 457; break;       /* ld2 --> ld2r.  */
9973     case 457: return NULL;              /* ld2r --> NULL.  */
9974     case 452: value = 454; break;       /* ld3 --> ld3r.  */
9975     case 454: return NULL;              /* ld3r --> NULL.  */
9976     case 456: value = 458; break;       /* ld4 --> ld4r.  */
9977     case 458: return NULL;              /* ld4r --> NULL.  */
9978     case 443: value = 444; break;       /* ld4 --> ld1.  */
9979     case 444: value = 445; break;       /* ld1 --> ld2.  */
9980     case 445: value = 446; break;       /* ld2 --> ld3.  */
9981     case 446: return NULL;              /* ld3 --> NULL.  */
9982     case 463: value = 465; break;       /* ld1 --> ld1r.  */
9983     case 465: return NULL;              /* ld1r --> NULL.  */
9984     case 464: value = 466; break;       /* ld3 --> ld3r.  */
9985     case 466: return NULL;              /* ld3r --> NULL.  */
9986     case 467: value = 469; break;       /* ld2 --> ld2r.  */
9987     case 469: return NULL;              /* ld2r --> NULL.  */
9988     case 468: value = 470; break;       /* ld4 --> ld4r.  */
9989     case 470: return NULL;              /* ld4r --> NULL.  */
9990     case 718: value = 719; break;       /* fcvtzs --> fcvtzs.  */
9991     case 719: return NULL;              /* fcvtzs --> NULL.  */
9992     case 714: value = 715; break;       /* scvtf --> scvtf.  */
9993     case 715: return NULL;              /* scvtf --> NULL.  */
9994     case 720: value = 721; break;       /* fcvtzu --> fcvtzu.  */
9995     case 721: return NULL;              /* fcvtzu --> NULL.  */
9996     case 716: value = 717; break;       /* ucvtf --> ucvtf.  */
9997     case 717: return NULL;              /* ucvtf --> NULL.  */
9998     case 722: value = 723; break;       /* fcvtns --> fcvtns.  */
9999     case 723: return NULL;              /* fcvtns --> NULL.  */
10000     case 742: value = 743; break;       /* fcvtms --> fcvtms.  */
10001     case 743: return NULL;              /* fcvtms --> NULL.  */
10002     case 738: value = 739; break;       /* fcvtps --> fcvtps.  */
10003     case 739: return NULL;              /* fcvtps --> NULL.  */
10004     case 746: value = 747; break;       /* fcvtzs --> fcvtzs.  */
10005     case 747: return NULL;              /* fcvtzs --> NULL.  */
10006     case 730: value = 731; break;       /* fcvtas --> fcvtas.  */
10007     case 731: return NULL;              /* fcvtas --> NULL.  */
10008     case 726: value = 727; break;       /* scvtf --> scvtf.  */
10009     case 727: return NULL;              /* scvtf --> NULL.  */
10010     case 734: value = 735; break;       /* fmov --> fmov.  */
10011     case 735: return NULL;              /* fmov --> NULL.  */
10012     case 724: value = 725; break;       /* fcvtnu --> fcvtnu.  */
10013     case 725: return NULL;              /* fcvtnu --> NULL.  */
10014     case 744: value = 745; break;       /* fcvtmu --> fcvtmu.  */
10015     case 745: return NULL;              /* fcvtmu --> NULL.  */
10016     case 740: value = 741; break;       /* fcvtpu --> fcvtpu.  */
10017     case 741: return NULL;              /* fcvtpu --> NULL.  */
10018     case 748: value = 749; break;       /* fcvtzu --> fcvtzu.  */
10019     case 749: return NULL;              /* fcvtzu --> NULL.  */
10020     case 732: value = 733; break;       /* fcvtau --> fcvtau.  */
10021     case 733: return NULL;              /* fcvtau --> NULL.  */
10022     case 728: value = 729; break;       /* ucvtf --> ucvtf.  */
10023     case 729: return NULL;              /* ucvtf --> NULL.  */
10024     case 736: value = 737; break;       /* fmov --> fmov.  */
10025     case 737: return NULL;              /* fmov --> NULL.  */
10026     case 764: value = 765; break;       /* fmov --> fmov.  */
10027     case 765: return NULL;              /* fmov --> NULL.  */
10028     case 773: value = 774; break;       /* frintn --> frintn.  */
10029     case 774: return NULL;              /* frintn --> NULL.  */
10030     case 768: value = 769; break;       /* fneg --> fneg.  */
10031     case 769: return NULL;              /* fneg --> NULL.  */
10032     case 777: value = 778; break;       /* frintm --> frintm.  */
10033     case 778: return NULL;              /* frintm --> NULL.  */
10034     case 766: value = 767; break;       /* fabs --> fabs.  */
10035     case 767: return NULL;              /* fabs --> NULL.  */
10036     case 775: value = 776; break;       /* frintp --> frintp.  */
10037     case 776: return NULL;              /* frintp --> NULL.  */
10038     case 770: value = 771; break;       /* fsqrt --> fsqrt.  */
10039     case 771: return NULL;              /* fsqrt --> NULL.  */
10040     case 779: value = 780; break;       /* frintz --> frintz.  */
10041     case 780: return NULL;              /* frintz --> NULL.  */
10042     case 781: value = 782; break;       /* frinta --> frinta.  */
10043     case 782: return NULL;              /* frinta --> NULL.  */
10044     case 783: value = 784; break;       /* frintx --> frintx.  */
10045     case 784: return NULL;              /* frintx --> NULL.  */
10046     case 785: value = 786; break;       /* frinti --> frinti.  */
10047     case 786: return NULL;              /* frinti --> NULL.  */
10048     case 756: value = 757; break;       /* fcmp --> fcmp.  */
10049     case 757: return NULL;              /* fcmp --> NULL.  */
10050     case 758: value = 759; break;       /* fcmpe --> fcmpe.  */
10051     case 759: return NULL;              /* fcmpe --> NULL.  */
10052     case 760: value = 761; break;       /* fcmp --> fcmp.  */
10053     case 761: return NULL;              /* fcmp --> NULL.  */
10054     case 762: value = 763; break;       /* fcmpe --> fcmpe.  */
10055     case 763: return NULL;              /* fcmpe --> NULL.  */
10056     case 813: value = 814; break;       /* fmov --> fmov.  */
10057     case 814: return NULL;              /* fmov --> NULL.  */
10058     case 787: value = 788; break;       /* fmul --> fmul.  */
10059     case 788: return NULL;              /* fmul --> NULL.  */
10060     case 803: value = 804; break;       /* fnmul --> fnmul.  */
10061     case 804: return NULL;              /* fnmul --> NULL.  */
10062     case 795: value = 796; break;       /* fmax --> fmax.  */
10063     case 796: return NULL;              /* fmax --> NULL.  */
10064     case 791: value = 792; break;       /* fadd --> fadd.  */
10065     case 792: return NULL;              /* fadd --> NULL.  */
10066     case 799: value = 800; break;       /* fmaxnm --> fmaxnm.  */
10067     case 800: return NULL;              /* fmaxnm --> NULL.  */
10068     case 789: value = 790; break;       /* fdiv --> fdiv.  */
10069     case 790: return NULL;              /* fdiv --> NULL.  */
10070     case 797: value = 798; break;       /* fmin --> fmin.  */
10071     case 798: return NULL;              /* fmin --> NULL.  */
10072     case 793: value = 794; break;       /* fsub --> fsub.  */
10073     case 794: return NULL;              /* fsub --> NULL.  */
10074     case 801: value = 802; break;       /* fminnm --> fminnm.  */
10075     case 802: return NULL;              /* fminnm --> NULL.  */
10076     case 752: value = 753; break;       /* fccmp --> fccmp.  */
10077     case 753: return NULL;              /* fccmp --> NULL.  */
10078     case 754: value = 755; break;       /* fccmpe --> fccmpe.  */
10079     case 755: return NULL;              /* fccmpe --> NULL.  */
10080     case 815: value = 816; break;       /* fcsel --> fcsel.  */
10081     case 816: return NULL;              /* fcsel --> NULL.  */
10082     case 130: value = 365; break;       /* movi --> sshr.  */
10083     case 365: value = 367; break;       /* sshr --> srshr.  */
10084     case 367: return NULL;              /* srshr --> NULL.  */
10085     case 138: value = 387; break;       /* mvni --> ushr.  */
10086     case 387: value = 389; break;       /* ushr --> urshr.  */
10087     case 389: value = 391; break;       /* urshr --> sri.  */
10088     case 391: value = 393; break;       /* sri --> sqshlu.  */
10089     case 393: return NULL;              /* sqshlu --> NULL.  */
10090     case 131: value = 366; break;       /* orr --> ssra.  */
10091     case 366: value = 368; break;       /* ssra --> srsra.  */
10092     case 368: value = 369; break;       /* srsra --> shl.  */
10093     case 369: value = 370; break;       /* shl --> sqshl.  */
10094     case 370: return NULL;              /* sqshl --> NULL.  */
10095     case 139: value = 388; break;       /* bic --> usra.  */
10096     case 388: value = 390; break;       /* usra --> ursra.  */
10097     case 390: value = 392; break;       /* ursra --> sli.  */
10098     case 392: value = 394; break;       /* sli --> uqshl.  */
10099     case 394: return NULL;              /* uqshl --> NULL.  */
10100     case 805: value = 806; break;       /* fmadd --> fmadd.  */
10101     case 806: return NULL;              /* fmadd --> NULL.  */
10102     case 809: value = 810; break;       /* fnmadd --> fnmadd.  */
10103     case 810: return NULL;              /* fnmadd --> NULL.  */
10104     case 132: value = 371; break;       /* movi --> shrn.  */
10105     case 371: value = 372; break;       /* shrn --> shrn2.  */
10106     case 372: value = 379; break;       /* shrn2 --> sshll.  */
10107     case 379: value = 381; break;       /* sshll --> sshll2.  */
10108     case 381: return NULL;              /* sshll2 --> NULL.  */
10109     case 140: value = 395; break;       /* mvni --> sqshrun.  */
10110     case 395: value = 396; break;       /* sqshrun --> sqshrun2.  */
10111     case 396: value = 403; break;       /* sqshrun2 --> ushll.  */
10112     case 403: value = 405; break;       /* ushll --> ushll2.  */
10113     case 405: return NULL;              /* ushll2 --> NULL.  */
10114     case 133: value = 375; break;       /* orr --> sqshrn.  */
10115     case 375: value = 376; break;       /* sqshrn --> sqshrn2.  */
10116     case 376: return NULL;              /* sqshrn2 --> NULL.  */
10117     case 141: value = 399; break;       /* bic --> uqshrn.  */
10118     case 399: value = 400; break;       /* uqshrn --> uqshrn2.  */
10119     case 400: return NULL;              /* uqshrn2 --> NULL.  */
10120     case 135: value = 383; break;       /* movi --> scvtf.  */
10121     case 383: value = 384; break;       /* scvtf --> scvtf.  */
10122     case 384: return NULL;              /* scvtf --> NULL.  */
10123     case 143: value = 144; break;       /* movi --> movi.  */
10124     case 144: value = 407; break;       /* movi --> ucvtf.  */
10125     case 407: value = 408; break;       /* ucvtf --> ucvtf.  */
10126     case 408: return NULL;              /* ucvtf --> NULL.  */
10127     case 137: value = 385; break;       /* fmov --> fcvtzs.  */
10128     case 385: value = 386; break;       /* fcvtzs --> fcvtzs.  */
10129     case 386: return NULL;              /* fcvtzs --> NULL.  */
10130     case 409: value = 410; break;       /* fcvtzu --> fcvtzu.  */
10131     case 410: return NULL;              /* fcvtzu --> NULL.  */
10132     case 807: value = 808; break;       /* fmsub --> fmsub.  */
10133     case 808: return NULL;              /* fmsub --> NULL.  */
10134     case 811: value = 812; break;       /* fnmsub --> fnmsub.  */
10135     case 812: return NULL;              /* fnmsub --> NULL.  */
10136     case 589: value = 590; break;       /* scvtf --> scvtf.  */
10137     case 590: return NULL;              /* scvtf --> NULL.  */
10138     case 591: value = 592; break;       /* fcvtzs --> fcvtzs.  */
10139     case 592: return NULL;              /* fcvtzs --> NULL.  */
10140     case 605: value = 606; break;       /* ucvtf --> ucvtf.  */
10141     case 606: return NULL;              /* ucvtf --> NULL.  */
10142     case 607: value = 608; break;       /* fcvtzu --> fcvtzu.  */
10143     case 608: return NULL;              /* fcvtzu --> NULL.  */
10144     default: return NULL;
10145     }
10146
10147   return aarch64_opcode_table + value;
10148 }
10149
10150 const aarch64_opcode *
10151 aarch64_find_alias_opcode (const aarch64_opcode *opcode)
10152 {
10153   /* Use the index as the key to locate the alias opcode.  */
10154   int key = opcode - aarch64_opcode_table;
10155   int value;
10156   switch (key)
10157     {
10158     case 2: value = 3; break;   /* sbc --> ngc.  */
10159     case 4: value = 5; break;   /* sbcs --> ngcs.  */
10160     case 7: value = 8; break;   /* adds --> cmn.  */
10161     case 10: value = 11; break; /* subs --> cmp.  */
10162     case 12: value = 13; break; /* add --> mov.  */
10163     case 14: value = 15; break; /* adds --> cmn.  */
10164     case 17: value = 18; break; /* subs --> cmp.  */
10165     case 20: value = 21; break; /* adds --> cmn.  */
10166     case 22: value = 23; break; /* sub --> neg.  */
10167     case 24: value = 26; break; /* subs --> negs.  */
10168     case 149: value = 150; break;       /* umov --> mov.  */
10169     case 151: value = 152; break;       /* ins --> mov.  */
10170     case 153: value = 154; break;       /* ins --> mov.  */
10171     case 235: value = 236; break;       /* not --> mvn.  */
10172     case 310: value = 311; break;       /* orr --> mov.  */
10173     case 379: value = 380; break;       /* sshll --> sxtl.  */
10174     case 381: value = 382; break;       /* sshll2 --> sxtl2.  */
10175     case 403: value = 404; break;       /* ushll --> uxtl.  */
10176     case 405: value = 406; break;       /* ushll2 --> uxtl2.  */
10177     case 526: value = 527; break;       /* dup --> mov.  */
10178     case 609: value = 614; break;       /* sbfm --> sxtw.  */
10179     case 616: value = 618; break;       /* bfm --> bfc.  */
10180     case 620: value = 624; break;       /* ubfm --> uxth.  */
10181     case 642: value = 644; break;       /* csinc --> cset.  */
10182     case 645: value = 647; break;       /* csinv --> csetm.  */
10183     case 648: value = 649; break;       /* csneg --> cneg.  */
10184     case 667: value = 667; break;       /* rev --> rev.  */
10185     case 674: value = 675; break;       /* lslv --> lsl.  */
10186     case 676: value = 677; break;       /* lsrv --> lsr.  */
10187     case 678: value = 679; break;       /* asrv --> asr.  */
10188     case 680: value = 681; break;       /* rorv --> ror.  */
10189     case 690: value = 691; break;       /* madd --> mul.  */
10190     case 692: value = 693; break;       /* msub --> mneg.  */
10191     case 694: value = 695; break;       /* smaddl --> smull.  */
10192     case 696: value = 697; break;       /* smsubl --> smnegl.  */
10193     case 699: value = 700; break;       /* umaddl --> umull.  */
10194     case 701: value = 702; break;       /* umsubl --> umnegl.  */
10195     case 712: value = 713; break;       /* extr --> ror.  */
10196     case 919: value = 920; break;       /* and --> bic.  */
10197     case 921: value = 922; break;       /* orr --> mov.  */
10198     case 924: value = 925; break;       /* ands --> tst.  */
10199     case 928: value = 930; break;       /* orr --> uxtw.  */
10200     case 931: value = 932; break;       /* orn --> mvn.  */
10201     case 935: value = 936; break;       /* ands --> tst.  */
10202     case 966: value = 1062; break;      /* ldaddb --> staddb.  */
10203     case 967: value = 1063; break;      /* ldaddh --> staddh.  */
10204     case 968: value = 1064; break;      /* ldadd --> stadd.  */
10205     case 970: value = 1065; break;      /* ldaddlb --> staddlb.  */
10206     case 973: value = 1066; break;      /* ldaddlh --> staddlh.  */
10207     case 976: value = 1067; break;      /* ldaddl --> staddl.  */
10208     case 978: value = 1068; break;      /* ldclrb --> stclrb.  */
10209     case 979: value = 1069; break;      /* ldclrh --> stclrh.  */
10210     case 980: value = 1070; break;      /* ldclr --> stclr.  */
10211     case 982: value = 1071; break;      /* ldclrlb --> stclrlb.  */
10212     case 985: value = 1072; break;      /* ldclrlh --> stclrlh.  */
10213     case 988: value = 1073; break;      /* ldclrl --> stclrl.  */
10214     case 990: value = 1074; break;      /* ldeorb --> steorb.  */
10215     case 991: value = 1075; break;      /* ldeorh --> steorh.  */
10216     case 992: value = 1076; break;      /* ldeor --> steor.  */
10217     case 994: value = 1077; break;      /* ldeorlb --> steorlb.  */
10218     case 997: value = 1078; break;      /* ldeorlh --> steorlh.  */
10219     case 1000: value = 1079; break;     /* ldeorl --> steorl.  */
10220     case 1002: value = 1080; break;     /* ldsetb --> stsetb.  */
10221     case 1003: value = 1081; break;     /* ldseth --> stseth.  */
10222     case 1004: value = 1082; break;     /* ldset --> stset.  */
10223     case 1006: value = 1083; break;     /* ldsetlb --> stsetlb.  */
10224     case 1009: value = 1084; break;     /* ldsetlh --> stsetlh.  */
10225     case 1012: value = 1085; break;     /* ldsetl --> stsetl.  */
10226     case 1014: value = 1086; break;     /* ldsmaxb --> stsmaxb.  */
10227     case 1015: value = 1087; break;     /* ldsmaxh --> stsmaxh.  */
10228     case 1016: value = 1088; break;     /* ldsmax --> stsmax.  */
10229     case 1018: value = 1089; break;     /* ldsmaxlb --> stsmaxlb.  */
10230     case 1021: value = 1090; break;     /* ldsmaxlh --> stsmaxlh.  */
10231     case 1024: value = 1091; break;     /* ldsmaxl --> stsmaxl.  */
10232     case 1026: value = 1092; break;     /* ldsminb --> stsminb.  */
10233     case 1027: value = 1093; break;     /* ldsminh --> stsminh.  */
10234     case 1028: value = 1094; break;     /* ldsmin --> stsmin.  */
10235     case 1030: value = 1095; break;     /* ldsminlb --> stsminlb.  */
10236     case 1033: value = 1096; break;     /* ldsminlh --> stsminlh.  */
10237     case 1036: value = 1097; break;     /* ldsminl --> stsminl.  */
10238     case 1038: value = 1098; break;     /* ldumaxb --> stumaxb.  */
10239     case 1039: value = 1099; break;     /* ldumaxh --> stumaxh.  */
10240     case 1040: value = 1100; break;     /* ldumax --> stumax.  */
10241     case 1042: value = 1101; break;     /* ldumaxlb --> stumaxlb.  */
10242     case 1045: value = 1102; break;     /* ldumaxlh --> stumaxlh.  */
10243     case 1048: value = 1103; break;     /* ldumaxl --> stumaxl.  */
10244     case 1050: value = 1104; break;     /* lduminb --> stuminb.  */
10245     case 1051: value = 1105; break;     /* lduminh --> stuminh.  */
10246     case 1052: value = 1106; break;     /* ldumin --> stumin.  */
10247     case 1054: value = 1107; break;     /* lduminlb --> stuminlb.  */
10248     case 1057: value = 1108; break;     /* lduminlh --> stuminlh.  */
10249     case 1060: value = 1109; break;     /* lduminl --> stuminl.  */
10250     case 1110: value = 1111; break;     /* movn --> mov.  */
10251     case 1112: value = 1113; break;     /* movz --> mov.  */
10252     case 1118: value = 1126; break;     /* hint --> psb.  */
10253     case 1131: value = 1135; break;     /* sys --> tlbi.  */
10254     default: return NULL;
10255     }
10256
10257   return aarch64_opcode_table + value;
10258 }
10259
10260 const aarch64_opcode *
10261 aarch64_find_next_alias_opcode (const aarch64_opcode *opcode)
10262 {
10263   /* Use the index as the key to locate the next opcode.  */
10264   int key = opcode - aarch64_opcode_table;
10265   int value;
10266   switch (key)
10267     {
10268     case 3: value = 2; break;   /* ngc --> sbc.  */
10269     case 5: value = 4; break;   /* ngcs --> sbcs.  */
10270     case 8: value = 7; break;   /* cmn --> adds.  */
10271     case 11: value = 10; break; /* cmp --> subs.  */
10272     case 13: value = 12; break; /* mov --> add.  */
10273     case 15: value = 14; break; /* cmn --> adds.  */
10274     case 18: value = 17; break; /* cmp --> subs.  */
10275     case 21: value = 20; break; /* cmn --> adds.  */
10276     case 23: value = 22; break; /* neg --> sub.  */
10277     case 26: value = 25; break; /* negs --> cmp.  */
10278     case 25: value = 24; break; /* cmp --> subs.  */
10279     case 150: value = 149; break;       /* mov --> umov.  */
10280     case 152: value = 151; break;       /* mov --> ins.  */
10281     case 154: value = 153; break;       /* mov --> ins.  */
10282     case 236: value = 235; break;       /* mvn --> not.  */
10283     case 311: value = 310; break;       /* mov --> orr.  */
10284     case 380: value = 379; break;       /* sxtl --> sshll.  */
10285     case 382: value = 381; break;       /* sxtl2 --> sshll2.  */
10286     case 404: value = 403; break;       /* uxtl --> ushll.  */
10287     case 406: value = 405; break;       /* uxtl2 --> ushll2.  */
10288     case 527: value = 526; break;       /* mov --> dup.  */
10289     case 614: value = 613; break;       /* sxtw --> sxth.  */
10290     case 613: value = 612; break;       /* sxth --> sxtb.  */
10291     case 612: value = 615; break;       /* sxtb --> asr.  */
10292     case 615: value = 611; break;       /* asr --> sbfx.  */
10293     case 611: value = 610; break;       /* sbfx --> sbfiz.  */
10294     case 610: value = 609; break;       /* sbfiz --> sbfm.  */
10295     case 618: value = 619; break;       /* bfc --> bfxil.  */
10296     case 619: value = 617; break;       /* bfxil --> bfi.  */
10297     case 617: value = 616; break;       /* bfi --> bfm.  */
10298     case 624: value = 623; break;       /* uxth --> uxtb.  */
10299     case 623: value = 626; break;       /* uxtb --> lsr.  */
10300     case 626: value = 625; break;       /* lsr --> lsl.  */
10301     case 625: value = 622; break;       /* lsl --> ubfx.  */
10302     case 622: value = 621; break;       /* ubfx --> ubfiz.  */
10303     case 621: value = 620; break;       /* ubfiz --> ubfm.  */
10304     case 644: value = 643; break;       /* cset --> cinc.  */
10305     case 643: value = 642; break;       /* cinc --> csinc.  */
10306     case 647: value = 646; break;       /* csetm --> cinv.  */
10307     case 646: value = 645; break;       /* cinv --> csinv.  */
10308     case 649: value = 648; break;       /* cneg --> csneg.  */
10309     case 667: value = 668; break;       /* rev --> rev64.  */
10310     case 675: value = 674; break;       /* lsl --> lslv.  */
10311     case 677: value = 676; break;       /* lsr --> lsrv.  */
10312     case 679: value = 678; break;       /* asr --> asrv.  */
10313     case 681: value = 680; break;       /* ror --> rorv.  */
10314     case 691: value = 690; break;       /* mul --> madd.  */
10315     case 693: value = 692; break;       /* mneg --> msub.  */
10316     case 695: value = 694; break;       /* smull --> smaddl.  */
10317     case 697: value = 696; break;       /* smnegl --> smsubl.  */
10318     case 700: value = 699; break;       /* umull --> umaddl.  */
10319     case 702: value = 701; break;       /* umnegl --> umsubl.  */
10320     case 713: value = 712; break;       /* ror --> extr.  */
10321     case 920: value = 919; break;       /* bic --> and.  */
10322     case 922: value = 921; break;       /* mov --> orr.  */
10323     case 925: value = 924; break;       /* tst --> ands.  */
10324     case 930: value = 929; break;       /* uxtw --> mov.  */
10325     case 929: value = 928; break;       /* mov --> orr.  */
10326     case 932: value = 931; break;       /* mvn --> orn.  */
10327     case 936: value = 935; break;       /* tst --> ands.  */
10328     case 1062: value = 966; break;      /* staddb --> ldaddb.  */
10329     case 1063: value = 967; break;      /* staddh --> ldaddh.  */
10330     case 1064: value = 968; break;      /* stadd --> ldadd.  */
10331     case 1065: value = 970; break;      /* staddlb --> ldaddlb.  */
10332     case 1066: value = 973; break;      /* staddlh --> ldaddlh.  */
10333     case 1067: value = 976; break;      /* staddl --> ldaddl.  */
10334     case 1068: value = 978; break;      /* stclrb --> ldclrb.  */
10335     case 1069: value = 979; break;      /* stclrh --> ldclrh.  */
10336     case 1070: value = 980; break;      /* stclr --> ldclr.  */
10337     case 1071: value = 982; break;      /* stclrlb --> ldclrlb.  */
10338     case 1072: value = 985; break;      /* stclrlh --> ldclrlh.  */
10339     case 1073: value = 988; break;      /* stclrl --> ldclrl.  */
10340     case 1074: value = 990; break;      /* steorb --> ldeorb.  */
10341     case 1075: value = 991; break;      /* steorh --> ldeorh.  */
10342     case 1076: value = 992; break;      /* steor --> ldeor.  */
10343     case 1077: value = 994; break;      /* steorlb --> ldeorlb.  */
10344     case 1078: value = 997; break;      /* steorlh --> ldeorlh.  */
10345     case 1079: value = 1000; break;     /* steorl --> ldeorl.  */
10346     case 1080: value = 1002; break;     /* stsetb --> ldsetb.  */
10347     case 1081: value = 1003; break;     /* stseth --> ldseth.  */
10348     case 1082: value = 1004; break;     /* stset --> ldset.  */
10349     case 1083: value = 1006; break;     /* stsetlb --> ldsetlb.  */
10350     case 1084: value = 1009; break;     /* stsetlh --> ldsetlh.  */
10351     case 1085: value = 1012; break;     /* stsetl --> ldsetl.  */
10352     case 1086: value = 1014; break;     /* stsmaxb --> ldsmaxb.  */
10353     case 1087: value = 1015; break;     /* stsmaxh --> ldsmaxh.  */
10354     case 1088: value = 1016; break;     /* stsmax --> ldsmax.  */
10355     case 1089: value = 1018; break;     /* stsmaxlb --> ldsmaxlb.  */
10356     case 1090: value = 1021; break;     /* stsmaxlh --> ldsmaxlh.  */
10357     case 1091: value = 1024; break;     /* stsmaxl --> ldsmaxl.  */
10358     case 1092: value = 1026; break;     /* stsminb --> ldsminb.  */
10359     case 1093: value = 1027; break;     /* stsminh --> ldsminh.  */
10360     case 1094: value = 1028; break;     /* stsmin --> ldsmin.  */
10361     case 1095: value = 1030; break;     /* stsminlb --> ldsminlb.  */
10362     case 1096: value = 1033; break;     /* stsminlh --> ldsminlh.  */
10363     case 1097: value = 1036; break;     /* stsminl --> ldsminl.  */
10364     case 1098: value = 1038; break;     /* stumaxb --> ldumaxb.  */
10365     case 1099: value = 1039; break;     /* stumaxh --> ldumaxh.  */
10366     case 1100: value = 1040; break;     /* stumax --> ldumax.  */
10367     case 1101: value = 1042; break;     /* stumaxlb --> ldumaxlb.  */
10368     case 1102: value = 1045; break;     /* stumaxlh --> ldumaxlh.  */
10369     case 1103: value = 1048; break;     /* stumaxl --> ldumaxl.  */
10370     case 1104: value = 1050; break;     /* stuminb --> lduminb.  */
10371     case 1105: value = 1051; break;     /* stuminh --> lduminh.  */
10372     case 1106: value = 1052; break;     /* stumin --> ldumin.  */
10373     case 1107: value = 1054; break;     /* stuminlb --> lduminlb.  */
10374     case 1108: value = 1057; break;     /* stuminlh --> lduminlh.  */
10375     case 1109: value = 1060; break;     /* stuminl --> lduminl.  */
10376     case 1111: value = 1110; break;     /* mov --> movn.  */
10377     case 1113: value = 1112; break;     /* mov --> movz.  */
10378     case 1126: value = 1125; break;     /* psb --> esb.  */
10379     case 1125: value = 1124; break;     /* esb --> sevl.  */
10380     case 1124: value = 1123; break;     /* sevl --> sev.  */
10381     case 1123: value = 1122; break;     /* sev --> wfi.  */
10382     case 1122: value = 1121; break;     /* wfi --> wfe.  */
10383     case 1121: value = 1120; break;     /* wfe --> yield.  */
10384     case 1120: value = 1119; break;     /* yield --> nop.  */
10385     case 1119: value = 1118; break;     /* nop --> hint.  */
10386     case 1135: value = 1134; break;     /* tlbi --> ic.  */
10387     case 1134: value = 1133; break;     /* ic --> dc.  */
10388     case 1133: value = 1132; break;     /* dc --> at.  */
10389     case 1132: value = 1131; break;     /* at --> sys.  */
10390     default: return NULL;
10391     }
10392
10393   return aarch64_opcode_table + value;
10394 }
10395
10396 int
10397 aarch64_extract_operand (const aarch64_operand *self,
10398                            aarch64_opnd_info *info,
10399                            aarch64_insn code, const aarch64_inst *inst)
10400 {
10401   /* Use the index as the key.  */
10402   int key = self - aarch64_operands;
10403   switch (key)
10404     {
10405     case 1:
10406     case 2:
10407     case 3:
10408     case 4:
10409     case 5:
10410     case 6:
10411     case 7:
10412     case 9:
10413     case 10:
10414     case 14:
10415     case 15:
10416     case 16:
10417     case 17:
10418     case 19:
10419     case 20:
10420     case 21:
10421     case 22:
10422     case 23:
10423     case 24:
10424     case 25:
10425     case 26:
10426     case 27:
10427     case 35:
10428     case 36:
10429       return aarch64_ext_regno (self, info, code, inst);
10430     case 8:
10431       return aarch64_ext_regrt_sysins (self, info, code, inst);
10432     case 11:
10433       return aarch64_ext_regno_pair (self, info, code, inst);
10434     case 12:
10435       return aarch64_ext_reg_extended (self, info, code, inst);
10436     case 13:
10437       return aarch64_ext_reg_shifted (self, info, code, inst);
10438     case 18:
10439       return aarch64_ext_ft (self, info, code, inst);
10440     case 28:
10441     case 29:
10442     case 30:
10443       return aarch64_ext_reglane (self, info, code, inst);
10444     case 31:
10445       return aarch64_ext_reglist (self, info, code, inst);
10446     case 32:
10447       return aarch64_ext_ldst_reglist (self, info, code, inst);
10448     case 33:
10449       return aarch64_ext_ldst_reglist_r (self, info, code, inst);
10450     case 34:
10451       return aarch64_ext_ldst_elemlist (self, info, code, inst);
10452     case 37:
10453     case 46:
10454     case 47:
10455     case 48:
10456     case 49:
10457     case 50:
10458     case 51:
10459     case 52:
10460     case 53:
10461     case 54:
10462     case 55:
10463     case 56:
10464     case 57:
10465     case 58:
10466     case 66:
10467     case 67:
10468     case 68:
10469     case 69:
10470     case 70:
10471       return aarch64_ext_imm (self, info, code, inst);
10472     case 38:
10473     case 39:
10474       return aarch64_ext_advsimd_imm_shift (self, info, code, inst);
10475     case 40:
10476     case 41:
10477     case 42:
10478       return aarch64_ext_advsimd_imm_modified (self, info, code, inst);
10479     case 43:
10480       return aarch64_ext_shll_imm (self, info, code, inst);
10481     case 59:
10482       return aarch64_ext_limm (self, info, code, inst);
10483     case 60:
10484       return aarch64_ext_aimm (self, info, code, inst);
10485     case 61:
10486       return aarch64_ext_imm_half (self, info, code, inst);
10487     case 62:
10488       return aarch64_ext_fbits (self, info, code, inst);
10489     case 64:
10490     case 65:
10491       return aarch64_ext_cond (self, info, code, inst);
10492     case 71:
10493     case 77:
10494       return aarch64_ext_addr_simple (self, info, code, inst);
10495     case 72:
10496       return aarch64_ext_addr_regoff (self, info, code, inst);
10497     case 73:
10498     case 74:
10499     case 75:
10500       return aarch64_ext_addr_simm (self, info, code, inst);
10501     case 76:
10502       return aarch64_ext_addr_uimm12 (self, info, code, inst);
10503     case 78:
10504       return aarch64_ext_simd_addr_post (self, info, code, inst);
10505     case 79:
10506       return aarch64_ext_sysreg (self, info, code, inst);
10507     case 80:
10508       return aarch64_ext_pstatefield (self, info, code, inst);
10509     case 81:
10510     case 82:
10511     case 83:
10512     case 84:
10513       return aarch64_ext_sysins_op (self, info, code, inst);
10514     case 85:
10515     case 86:
10516       return aarch64_ext_barrier (self, info, code, inst);
10517     case 87:
10518       return aarch64_ext_prfop (self, info, code, inst);
10519     case 88:
10520       return aarch64_ext_hint (self, info, code, inst);
10521     default: assert (0); abort ();
10522     }
10523 }