opcodes/aarch64-dis-2.c

   1 /* This file is automatically generated by aarch64-gen.  Do not edit!  */
   2 /* Copyright 2012, 2013  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 781;
  44                     }
  45                   else
  46                     {
  47                       /* 33222222222211111111110000000000
  48                          10987654321098765432109876543210
  49                          xxxxxxxxxxxxxxxxxxxxxxxx0000xxx1
  50                          adrp.  */
  51                       return 782;
  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 717;
 119                                             }
 120                                           else
 121                                             {
 122                                               /* 33222222222211111111110000000000
 123                                                  10987654321098765432109876543210
 124                                                  xxxxxxxxxxxxxxx0xxxxx000x0010010
 125                                                  stxrh.  */
 126                                               return 723;
 127                                             }
 128                                         }
 129                                       else
 130                                         {
 131                                           /* 33222222222211111111110000000000
 132                                              10987654321098765432109876543210
 133                                              xxxxxxxxxxxxxxx0xxxxx000x00100x1
 134                                              stxr.  */
 135                                           return 729;
 136                                         }
 137                                     }
 138                                   else
 139                                     {
 140                                       /* 33222222222211111111110000000000
 141                                          10987654321098765432109876543210
 142                                          xxxxxxxxxxxxxxx0xxxxx100x00100xx
 143                                          stxp.  */
 144                                       return 731;
 145                                     }
 146                                 }
 147                               else
 148                                 {
 149                                   if (((word >> 21) & 0x1) == 0)
 150                                     {
 151                                       if (((word >> 31) & 0x1) == 0)
 152                                         {
 153                                           if (((word >> 30) & 0x1) == 0)
 154                                             {
 155                                               /* 33222222222211111111110000000000
 156                                                  10987654321098765432109876543210
 157                                                  xxxxxxxxxxxxxxx1xxxxx000x0010000
 158                                                  stlxrb.  */
 159                                               return 718;
 160                                             }
 161                                           else
 162                                             {
 163                                               /* 33222222222211111111110000000000
 164                                                  10987654321098765432109876543210
 165                                                  xxxxxxxxxxxxxxx1xxxxx000x0010010
 166                                                  stlxrh.  */
 167                                               return 724;
 168                                             }
 169                                         }
 170                                       else
 171                                         {
 172                                           /* 33222222222211111111110000000000
 173                                              10987654321098765432109876543210
 174                                              xxxxxxxxxxxxxxx1xxxxx000x00100x1
 175                                              stlxr.  */
 176                                           return 730;
 177                                         }
 178                                     }
 179                                   else
 180                                     {
 181                                       /* 33222222222211111111110000000000
 182                                          10987654321098765432109876543210
 183                                          xxxxxxxxxxxxxxx1xxxxx100x00100xx
 184                                          stlxp.  */
 185                                       return 732;
 186                                     }
 187                                 }
 188                             }
 189                           else
 190                             {
 191                               /* 33222222222211111111110000000000
 192                                  10987654321098765432109876543210
 193                                  xxxxxxxxxxxxxxxxxxxxxx00x00101xx
 194                                  stnp.  */
 195                               return 739;
 196                             }
 197                         }
 198                       else
 199                         {
 200                           if (((word >> 29) & 0x1) == 0)
 201                             {
 202                               if (((word >> 31) & 0x1) == 0)
 203                                 {
 204                                   if (((word >> 30) & 0x1) == 0)
 205                                     {
 206                                       /* 33222222222211111111110000000000
 207                                          10987654321098765432109876543210
 208                                          xxxxxxxxxxxxxxxxxxxxxx01x0010000
 209                                          stlrb.  */
 210                                       return 721;
 211                                     }
 212                                   else
 213                                     {
 214                                       /* 33222222222211111111110000000000
 215                                          10987654321098765432109876543210
 216                                          xxxxxxxxxxxxxxxxxxxxxx01x0010010
 217                                          stlrh.  */
 218                                       return 727;
 219                                     }
 220                                 }
 221                               else
 222                                 {
 223                                   /* 33222222222211111111110000000000
 224                                      10987654321098765432109876543210
 225                                      xxxxxxxxxxxxxxxxxxxxxx01x00100x1
 226                                      stlr.  */
 227                                   return 737;
 228                                 }
 229                             }
 230                           else
 231                             {
 232                               /* 33222222222211111111110000000000
 233                                  10987654321098765432109876543210
 234                                  xxxxxxxxxxxxxxxxxxxxxx01x00101xx
 235                                  stp.  */
 236                               return 748;
 237                             }
 238                         }
 239                     }
 240                   else
 241                     {
 242                       if (((word >> 23) & 0x1) == 0)
 243                         {
 244                           if (((word >> 29) & 0x1) == 0)
 245                             {
 246                               if (((word >> 15) & 0x1) == 0)
 247                                 {
 248                                   if (((word >> 21) & 0x1) == 0)
 249                                     {
 250                                       if (((word >> 31) & 0x1) == 0)
 251                                         {
 252                                           if (((word >> 30) & 0x1) == 0)
 253                                             {
 254                                               /* 33222222222211111111110000000000
 255                                                  10987654321098765432109876543210
 256                                                  xxxxxxxxxxxxxxx0xxxxx010x0010000
 257                                                  ldxrb.  */
 258                                               return 719;
 259                                             }
 260                                           else
 261                                             {
 262                                               /* 33222222222211111111110000000000
 263                                                  10987654321098765432109876543210
 264                                                  xxxxxxxxxxxxxxx0xxxxx010x0010010
 265                                                  ldxrh.  */
 266                                               return 725;
 267                                             }
 268                                         }
 269                                       else
 270                                         {
 271                                           /* 33222222222211111111110000000000
 272                                              10987654321098765432109876543210
 273                                              xxxxxxxxxxxxxxx0xxxxx010x00100x1
 274                                              ldxr.  */
 275                                           return 733;
 276                                         }
 277                                     }
 278                                   else
 279                                     {
 280                                       /* 33222222222211111111110000000000
 281                                          10987654321098765432109876543210
 282                                          xxxxxxxxxxxxxxx0xxxxx110x00100xx
 283                                          ldxp.  */
 284                                       return 735;
 285                                     }
 286                                 }
 287                               else
 288                                 {
 289                                   if (((word >> 21) & 0x1) == 0)
 290                                     {
 291                                       if (((word >> 31) & 0x1) == 0)
 292                                         {
 293                                           if (((word >> 30) & 0x1) == 0)
 294                                             {
 295                                               /* 33222222222211111111110000000000
 296                                                  10987654321098765432109876543210
 297                                                  xxxxxxxxxxxxxxx1xxxxx010x0010000
 298                                                  ldaxrb.  */
 299                                               return 720;
 300                                             }
 301                                           else
 302                                             {
 303                                               /* 33222222222211111111110000000000
 304                                                  10987654321098765432109876543210
 305                                                  xxxxxxxxxxxxxxx1xxxxx010x0010010
 306                                                  ldaxrh.  */
 307                                               return 726;
 308                                             }
 309                                         }
 310                                       else
 311                                         {
 312                                           /* 33222222222211111111110000000000
 313                                              10987654321098765432109876543210
 314                                              xxxxxxxxxxxxxxx1xxxxx010x00100x1
 315                                              ldaxr.  */
 316                                           return 734;
 317                                         }
 318                                     }
 319                                   else
 320                                     {
 321                                       /* 33222222222211111111110000000000
 322                                          10987654321098765432109876543210
 323                                          xxxxxxxxxxxxxxx1xxxxx110x00100xx
 324                                          ldaxp.  */
 325                                       return 736;
 326                                     }
 327                                 }
 328                             }
 329                           else
 330                             {
 331                               if (((word >> 30) & 0x1) == 0)
 332                                 {
 333                                   /* 33222222222211111111110000000000
 334                                      10987654321098765432109876543210
 335                                      xxxxxxxxxxxxxxxxxxxxxx10x001010x
 336                                      ldnp.  */
 337                                   return 740;
 338                                 }
 339                               else
 340                                 {
 341                                   /* 33222222222211111111110000000000
 342                                      10987654321098765432109876543210
 343                                      xxxxxxxxxxxxxxxxxxxxxx10x001011x
 344                                      ldpsw.  */
 345                                   return 747;
 346                                 }
 347                             }
 348                         }
 349                       else
 350                         {
 351                           if (((word >> 29) & 0x1) == 0)
 352                             {
 353                               if (((word >> 31) & 0x1) == 0)
 354                                 {
 355                                   if (((word >> 30) & 0x1) == 0)
 356                                     {
 357                                       /* 33222222222211111111110000000000
 358                                          10987654321098765432109876543210
 359                                          xxxxxxxxxxxxxxxxxxxxxx11x0010000
 360                                          ldarb.  */
 361                                       return 722;
 362                                     }
 363                                   else
 364                                     {
 365                                       /* 33222222222211111111110000000000
 366                                          10987654321098765432109876543210
 367                                          xxxxxxxxxxxxxxxxxxxxxx11x0010010
 368                                          ldarh.  */
 369                                       return 728;
 370                                     }
 371                                 }
 372                               else
 373                                 {
 374                                   /* 33222222222211111111110000000000
 375                                      10987654321098765432109876543210
 376                                      xxxxxxxxxxxxxxxxxxxxxx11x00100x1
 377                                      ldar.  */
 378                                   return 738;
 379                                 }
 380                             }
 381                           else
 382                             {
 383                               if (((word >> 30) & 0x1) == 0)
 384                                 {
 385                                   /* 33222222222211111111110000000000
 386                                      10987654321098765432109876543210
 387                                      xxxxxxxxxxxxxxxxxxxxxx11x001010x
 388                                      ldp.  */
 389                                   return 749;
 390                                 }
 391                               else
 392                                 {
 393                                   /* 33222222222211111111110000000000
 394                                      10987654321098765432109876543210
 395                                      xxxxxxxxxxxxxxxxxxxxxx11x001011x
 396                                      ldpsw.  */
 397                                   return 752;
 398                                 }
 399                             }
 400                         }
 401                     }
 402                 }
 403               else
 404                 {
 405                   if (((word >> 24) & 0x1) == 0)
 406                     {
 407                       if (((word >> 29) & 0x1) == 0)
 408                         {
 409                           if (((word >> 31) & 0x1) == 0)
 410                             {
 411                               /* 33222222222211111111110000000000
 412                                  10987654321098765432109876543210
 413                                  xxxxxxxxxxxxxxxxxxxxxxxx000110x0
 414                                  ldr.  */
 415                               return 753;
 416                             }
 417                           else
 418                             {
 419                               if (((word >> 30) & 0x1) == 0)
 420                                 {
 421                                   /* 33222222222211111111110000000000
 422                                      10987654321098765432109876543210
 423                                      xxxxxxxxxxxxxxxxxxxxxxxx00011001
 424                                      ldrsw.  */
 425                                   return 755;
 426                                 }
 427                               else
 428                                 {
 429                                   /* 33222222222211111111110000000000
 430                                      10987654321098765432109876543210
 431                                      xxxxxxxxxxxxxxxxxxxxxxxx00011011
 432                                      prfm.  */
 433                                   return 756;
 434                                 }
 435                             }
 436                         }
 437                       else
 438                         {
 439                           if (((word >> 10) & 0x1) == 0)
 440                             {
 441                               if (((word >> 11) & 0x1) == 0)
 442                                 {
 443                                   if (((word >> 23) & 0x1) == 0)
 444                                     {
 445                                       if (((word >> 22) & 0x1) == 0)
 446                                         {
 447                                           if (((word >> 31) & 0x1) == 0)
 448                                             {
 449                                               if (((word >> 30) & 0x1) == 0)
 450                                                 {
 451                                                   /* 33222222222211111111110000000000
 452                                                      10987654321098765432109876543210
 453                                                      xxxxxxxxxx00xxxxxxxxxx0000011100
 454                                                      sturb.  */
 455                                                   return 693;
 456                                                 }
 457                                               else
 458                                                 {
 459                                                   /* 33222222222211111111110000000000
 460                                                      10987654321098765432109876543210
 461                                                      xxxxxxxxxx00xxxxxxxxxx0000011110
 462                                                      sturh.  */
 463                                                   return 703;
 464                                                 }
 465                                             }
 466                                           else
 467                                             {
 468                                               /* 33222222222211111111110000000000
 469                                                  10987654321098765432109876543210
 470                                                  xxxxxxxxxx00xxxxxxxxxx00000111x1
 471                                                  stur.  */
 472                                               return 709;
 473                                             }
 474                                         }
 475                                       else
 476                                         {
 477                                           if (((word >> 31) & 0x1) == 0)
 478                                             {
 479                                               if (((word >> 30) & 0x1) == 0)
 480                                                 {
 481                                                   /* 33222222222211111111110000000000
 482                                                      10987654321098765432109876543210
 483                                                      xxxxxxxxxx00xxxxxxxxxx1000011100
 484                                                      ldurb.  */
 485                                                   return 694;
 486                                                 }
 487                                               else
 488                                                 {
 489                                                   /* 33222222222211111111110000000000
 490                                                      10987654321098765432109876543210
 491                                                      xxxxxxxxxx00xxxxxxxxxx1000011110
 492                                                      ldurh.  */
 493                                                   return 704;
 494                                                 }
 495                                             }
 496                                           else
 497                                             {
 498                                               /* 33222222222211111111110000000000
 499                                                  10987654321098765432109876543210
 500                                                  xxxxxxxxxx00xxxxxxxxxx10000111x1
 501                                                  ldur.  */
 502                                               return 710;
 503                                             }
 504                                         }
 505                                     }
 506                                   else
 507                                     {
 508                                       if (((word >> 30) & 0x1) == 0)
 509                                         {
 510                                           if (((word >> 31) & 0x1) == 0)
 511                                             {
 512                                               /* 33222222222211111111110000000000
 513                                                  10987654321098765432109876543210
 514                                                  xxxxxxxxxx00xxxxxxxxxxx100011100
 515                                                  ldursb.  */
 516                                               return 697;
 517                                             }
 518                                           else
 519                                             {
 520                                               /* 33222222222211111111110000000000
 521                                                  10987654321098765432109876543210
 522                                                  xxxxxxxxxx00xxxxxxxxxxx100011101
 523                                                  ldursw.  */
 524                                               return 713;
 525                                             }
 526                                         }
 527                                       else
 528                                         {
 529                                           if (((word >> 31) & 0x1) == 0)
 530                                             {
 531                                               /* 33222222222211111111110000000000
 532                                                  10987654321098765432109876543210
 533                                                  xxxxxxxxxx00xxxxxxxxxxx100011110
 534                                                  ldursh.  */
 535                                               return 707;
 536                                             }
 537                                           else
 538                                             {
 539                                               /* 33222222222211111111110000000000
 540                                                  10987654321098765432109876543210
 541                                                  xxxxxxxxxx00xxxxxxxxxxx100011111
 542                                                  prfum.  */
 543                                               return 715;
 544                                             }
 545                                         }
 546                                     }
 547                                 }
 548                               else
 549                                 {
 550                                   if (((word >> 21) & 0x1) == 0)
 551                                     {
 552                                       if (((word >> 23) & 0x1) == 0)
 553                                         {
 554                                           if (((word >> 22) & 0x1) == 0)
 555                                             {
 556                                               if (((word >> 31) & 0x1) == 0)
 557                                                 {
 558                                                   if (((word >> 30) & 0x1) == 0)
 559                                                     {
 560                                                       /* 33222222222211111111110000000000
 561                                                          10987654321098765432109876543210
 562                                                          xxxxxxxxxx01xxxxxxxxx00000011100
 563                                                          sttrb.  */
 564                                                       return 684;
 565                                                     }
 566                                                   else
 567                                                     {
 568                                                       /* 33222222222211111111110000000000
 569                                                          10987654321098765432109876543210
 570                                                          xxxxxxxxxx01xxxxxxxxx00000011110
 571                                                          sttrh.  */
 572                                                       return 687;
 573                                                     }
 574                                                 }
 575                                               else
 576                                                 {
 577                                                   /* 33222222222211111111110000000000
 578                                                      10987654321098765432109876543210
 579                                                      xxxxxxxxxx01xxxxxxxxx000000111x1
 580                                                      sttr.  */
 581                                                   return 690;
 582                                                 }
 583                                             }
 584                                           else
 585                                             {
 586                                               if (((word >> 31) & 0x1) == 0)
 587                                                 {
 588                                                   if (((word >> 30) & 0x1) == 0)
 589                                                     {
 590                                                       /* 33222222222211111111110000000000
 591                                                          10987654321098765432109876543210
 592                                                          xxxxxxxxxx01xxxxxxxxx01000011100
 593                                                          ldtrb.  */
 594                                                       return 685;
 595                                                     }
 596                                                   else
 597                                                     {
 598                                                       /* 33222222222211111111110000000000
 599                                                          10987654321098765432109876543210
 600                                                          xxxxxxxxxx01xxxxxxxxx01000011110
 601                                                          ldtrh.  */
 602                                                       return 688;
 603                                                     }
 604                                                 }
 605                                               else
 606                                                 {
 607                                                   /* 33222222222211111111110000000000
 608                                                      10987654321098765432109876543210
 609                                                      xxxxxxxxxx01xxxxxxxxx010000111x1
 610                                                      ldtr.  */
 611                                                   return 691;
 612                                                 }
 613                                             }
 614                                         }
 615                                       else
 616                                         {
 617                                           if (((word >> 30) & 0x1) == 0)
 618                                             {
 619                                               if (((word >> 31) & 0x1) == 0)
 620                                                 {
 621                                                   /* 33222222222211111111110000000000
 622                                                      10987654321098765432109876543210
 623                                                      xxxxxxxxxx01xxxxxxxxx0x100011100
 624                                                      ldtrsb.  */
 625                                                   return 686;
 626                                                 }
 627                                               else
 628                                                 {
 629                                                   /* 33222222222211111111110000000000
 630                                                      10987654321098765432109876543210
 631                                                      xxxxxxxxxx01xxxxxxxxx0x100011101
 632                                                      ldtrsw.  */
 633                                                   return 692;
 634                                                 }
 635                                             }
 636                                           else
 637                                             {
 638                                               /* 33222222222211111111110000000000
 639                                                  10987654321098765432109876543210
 640                                                  xxxxxxxxxx01xxxxxxxxx0x10001111x
 641                                                  ldtrsh.  */
 642                                               return 689;
 643                                             }
 644                                         }
 645                                     }
 646                                   else
 647                                     {
 648                                       if (((word >> 23) & 0x1) == 0)
 649                                         {
 650                                           if (((word >> 22) & 0x1) == 0)
 651                                             {
 652                                               if (((word >> 31) & 0x1) == 0)
 653                                                 {
 654                                                   if (((word >> 30) & 0x1) == 0)
 655                                                     {
 656                                                       /* 33222222222211111111110000000000
 657                                                          10987654321098765432109876543210
 658                                                          xxxxxxxxxx01xxxxxxxxx10000011100
 659                                                          strb.  */
 660                                                       return 672;
 661                                                     }
 662                                                   else
 663                                                     {
 664                                                       /* 33222222222211111111110000000000
 665                                                          10987654321098765432109876543210
 666                                                          xxxxxxxxxx01xxxxxxxxx10000011110
 667                                                          strh.  */
 668                                                       return 677;
 669                                                     }
 670                                                 }
 671                                               else
 672                                                 {
 673                                                   /* 33222222222211111111110000000000
 674                                                      10987654321098765432109876543210
 675                                                      xxxxxxxxxx01xxxxxxxxx100000111x1
 676                                                      str.  */
 677                                                   return 680;
 678                                                 }
 679                                             }
 680                                           else
 681                                             {
 682                                               if (((word >> 31) & 0x1) == 0)
 683                                                 {
 684                                                   if (((word >> 30) & 0x1) == 0)
 685                                                     {
 686                                                       /* 33222222222211111111110000000000
 687                                                          10987654321098765432109876543210
 688                                                          xxxxxxxxxx01xxxxxxxxx11000011100
 689                                                          ldrb.  */
 690                                                       return 673;
 691                                                     }
 692                                                   else
 693                                                     {
 694                                                       /* 33222222222211111111110000000000
 695                                                          10987654321098765432109876543210
 696                                                          xxxxxxxxxx01xxxxxxxxx11000011110
 697                                                          ldrh.  */
 698                                                       return 678;
 699                                                     }
 700                                                 }
 701                                               else
 702                                                 {
 703                                                   /* 33222222222211111111110000000000
 704                                                      10987654321098765432109876543210
 705                                                      xxxxxxxxxx01xxxxxxxxx110000111x1
 706                                                      ldr.  */
 707                                                   return 681;
 708                                                 }
 709                                             }
 710                                         }
 711                                       else
 712                                         {
 713                                           if (((word >> 30) & 0x1) == 0)
 714                                             {
 715                                               if (((word >> 31) & 0x1) == 0)
 716                                                 {
 717                                                   /* 33222222222211111111110000000000
 718                                                      10987654321098765432109876543210
 719                                                      xxxxxxxxxx01xxxxxxxxx1x100011100
 720                                                      ldrsb.  */
 721                                                   return 674;
 722                                                 }
 723                                               else
 724                                                 {
 725                                                   /* 33222222222211111111110000000000
 726                                                      10987654321098765432109876543210
 727                                                      xxxxxxxxxx01xxxxxxxxx1x100011101
 728                                                      ldrsw.  */
 729                                                   return 682;
 730                                                 }
 731                                             }
 732                                           else
 733                                             {
 734                                               if (((word >> 31) & 0x1) == 0)
 735                                                 {
 736                                                   /* 33222222222211111111110000000000
 737                                                      10987654321098765432109876543210
 738                                                      xxxxxxxxxx01xxxxxxxxx1x100011110
 739                                                      ldrsh.  */
 740                                                   return 679;
 741                                                 }
 742                                               else
 743                                                 {
 744                                                   /* 33222222222211111111110000000000
 745                                                      10987654321098765432109876543210
 746                                                      xxxxxxxxxx01xxxxxxxxx1x100011111
 747                                                      prfm.  */
 748                                                   return 683;
 749                                                 }
 750                                             }
 751                                         }
 752                                     }
 753                                 }
 754                             }
 755                           else
 756                             {
 757                               if (((word >> 23) & 0x1) == 0)
 758                                 {
 759                                   if (((word >> 22) & 0x1) == 0)
 760                                     {
 761                                       if (((word >> 31) & 0x1) == 0)
 762                                         {
 763                                           if (((word >> 30) & 0x1) == 0)
 764                                             {
 765                                               /* 33222222222211111111110000000000
 766                                                  10987654321098765432109876543210
 767                                                  xxxxxxxxxx1xxxxxxxxxxx0000011100
 768                                                  strb.  */
 769                                               return 649;
 770                                             }
 771                                           else
 772                                             {
 773                                               /* 33222222222211111111110000000000
 774                                                  10987654321098765432109876543210
 775                                                  xxxxxxxxxx1xxxxxxxxxxx0000011110
 776                                                  strh.  */
 777                                               return 654;
 778                                             }
 779                                         }
 780                                       else
 781                                         {
 782                                           /* 33222222222211111111110000000000
 783                                              10987654321098765432109876543210
 784                                              xxxxxxxxxx1xxxxxxxxxxx00000111x1
 785                                              str.  */
 786                                           return 657;
 787                                         }
 788                                     }
 789                                   else
 790                                     {
 791                                       if (((word >> 31) & 0x1) == 0)
 792                                         {
 793                                           if (((word >> 30) & 0x1) == 0)
 794                                             {
 795                                               /* 33222222222211111111110000000000
 796                                                  10987654321098765432109876543210
 797                                                  xxxxxxxxxx1xxxxxxxxxxx1000011100
 798                                                  ldrb.  */
 799                                               return 650;
 800                                             }
 801                                           else
 802                                             {
 803                                               /* 33222222222211111111110000000000
 804                                                  10987654321098765432109876543210
 805                                                  xxxxxxxxxx1xxxxxxxxxxx1000011110
 806                                                  ldrh.  */
 807                                               return 655;
 808                                             }
 809                                         }
 810                                       else
 811                                         {
 812                                           /* 33222222222211111111110000000000
 813                                              10987654321098765432109876543210
 814                                              xxxxxxxxxx1xxxxxxxxxxx10000111x1
 815                                              ldr.  */
 816                                           return 658;
 817                                         }
 818                                     }
 819                                 }
 820                               else
 821                                 {
 822                                   if (((word >> 30) & 0x1) == 0)
 823                                     {
 824                                       if (((word >> 31) & 0x1) == 0)
 825                                         {
 826                                           /* 33222222222211111111110000000000
 827                                              10987654321098765432109876543210
 828                                              xxxxxxxxxx1xxxxxxxxxxxx100011100
 829                                              ldrsb.  */
 830                                           return 651;
 831                                         }
 832                                       else
 833                                         {
 834                                           /* 33222222222211111111110000000000
 835                                              10987654321098765432109876543210
 836                                              xxxxxxxxxx1xxxxxxxxxxxx100011101
 837                                              ldrsw.  */
 838                                           return 659;
 839                                         }
 840                                     }
 841                                   else
 842                                     {
 843                                       /* 33222222222211111111110000000000
 844                                          10987654321098765432109876543210
 845                                          xxxxxxxxxx1xxxxxxxxxxxx10001111x
 846                                          ldrsh.  */
 847                                       return 656;
 848                                     }
 849                                 }
 850                             }
 851                         }
 852                     }
 853                   else
 854                     {
 855                       if (((word >> 23) & 0x1) == 0)
 856                         {
 857                           if (((word >> 22) & 0x1) == 0)
 858                             {
 859                               if (((word >> 31) & 0x1) == 0)
 860                                 {
 861                                   if (((word >> 30) & 0x1) == 0)
 862                                     {
 863                                       /* 33222222222211111111110000000000
 864                                          10987654321098765432109876543210
 865                                          xxxxxxxxxxxxxxxxxxxxxx0010011x00
 866                                          strb.  */
 867                                       return 660;
 868                                     }
 869                                   else
 870                                     {
 871                                       /* 33222222222211111111110000000000
 872                                          10987654321098765432109876543210
 873                                          xxxxxxxxxxxxxxxxxxxxxx0010011x10
 874                                          strh.  */
 875                                       return 665;
 876                                     }
 877                                 }
 878                               else
 879                                 {
 880                                   /* 33222222222211111111110000000000
 881                                      10987654321098765432109876543210
 882                                      xxxxxxxxxxxxxxxxxxxxxx0010011xx1
 883                                      str.  */
 884                                   return 668;
 885                                 }
 886                             }
 887                           else
 888                             {
 889                               if (((word >> 31) & 0x1) == 0)
 890                                 {
 891                                   if (((word >> 30) & 0x1) == 0)
 892                                     {
 893                                       /* 33222222222211111111110000000000
 894                                          10987654321098765432109876543210
 895                                          xxxxxxxxxxxxxxxxxxxxxx1010011x00
 896                                          ldrb.  */
 897                                       return 661;
 898                                     }
 899                                   else
 900                                     {
 901                                       /* 33222222222211111111110000000000
 902                                          10987654321098765432109876543210
 903                                          xxxxxxxxxxxxxxxxxxxxxx1010011x10
 904                                          ldrh.  */
 905                                       return 666;
 906                                     }
 907                                 }
 908                               else
 909                                 {
 910                                   /* 33222222222211111111110000000000
 911                                      10987654321098765432109876543210
 912                                      xxxxxxxxxxxxxxxxxxxxxx1010011xx1
 913                                      ldr.  */
 914                                   return 669;
 915                                 }
 916                             }
 917                         }
 918                       else
 919                         {
 920                           if (((word >> 30) & 0x1) == 0)
 921                             {
 922                               if (((word >> 31) & 0x1) == 0)
 923                                 {
 924                                   /* 33222222222211111111110000000000
 925                                      10987654321098765432109876543210
 926                                      xxxxxxxxxxxxxxxxxxxxxxx110011x00
 927                                      ldrsb.  */
 928                                   return 662;
 929                                 }
 930                               else
 931                                 {
 932                                   /* 33222222222211111111110000000000
 933                                      10987654321098765432109876543210
 934                                      xxxxxxxxxxxxxxxxxxxxxxx110011x01
 935                                      ldrsw.  */
 936                                   return 670;
 937                                 }
 938                             }
 939                           else
 940                             {
 941                               if (((word >> 31) & 0x1) == 0)
 942                                 {
 943                                   /* 33222222222211111111110000000000
 944                                      10987654321098765432109876543210
 945                                      xxxxxxxxxxxxxxxxxxxxxxx110011x10
 946                                      ldrsh.  */
 947                                   return 667;
 948                                 }
 949                               else
 950                                 {
 951                                   /* 33222222222211111111110000000000
 952                                      10987654321098765432109876543210
 953                                      xxxxxxxxxxxxxxxxxxxxxxx110011x11
 954                                      prfm.  */
 955                                   return 671;
 956                                 }
 957                             }
 958                         }
 959                     }
 960                 }
 961             }
 962         }
 963       else
 964         {
 965           if (((word >> 24) & 0x1) == 0)
 966             {
 967               if (((word >> 27) & 0x1) == 0)
 968                 {
 969                   if (((word >> 23) & 0x1) == 0)
 970                     {
 971                       if (((word >> 29) & 0x1) == 0)
 972                         {
 973                           if (((word >> 30) & 0x1) == 0)
 974                             {
 975                               /* 33222222222211111111110000000000
 976                                  10987654321098765432109876543210
 977                                  xxxxxxxxxxxxxxxxxxxxxxx00100x00x
 978                                  and.  */
 979                               return 757;
 980                             }
 981                           else
 982                             {
 983                               /* 33222222222211111111110000000000
 984                                  10987654321098765432109876543210
 985                                  xxxxxxxxxxxxxxxxxxxxxxx00100x01x
 986                                  eor.  */
 987                               return 761;
 988                             }
 989                         }
 990                       else
 991                         {
 992                           if (((word >> 30) & 0x1) == 0)
 993                             {
 994                               /* 33222222222211111111110000000000
 995                                  10987654321098765432109876543210
 996                                  xxxxxxxxxxxxxxxxxxxxxxx00100x10x
 997                                  orr.  */
 998                               return 759;
 999                             }
1000                           else
1001                             {
1002                               /* 33222222222211111111110000000000
1003                                  10987654321098765432109876543210
1004                                  xxxxxxxxxxxxxxxxxxxxxxx00100x11x
1005                                  ands.  */
1006                               return 762;
1007                             }
1008                         }
1009                     }
1010                   else
1011                     {
1012                       if (((word >> 29) & 0x1) == 0)
1013                         {
1014                           if (((word >> 30) & 0x1) == 0)
1015                             {
1016                               /* 33222222222211111111110000000000
1017                                  10987654321098765432109876543210
1018                                  xxxxxxxxxxxxxxxxxxxxxxx10100x00x
1019                                  movn.  */
1020                               return 776;
1021                             }
1022                           else
1023                             {
1024                               /* 33222222222211111111110000000000
1025                                  10987654321098765432109876543210
1026                                  xxxxxxxxxxxxxxxxxxxxxxx10100x01x
1027                                  movz.  */
1028                               return 778;
1029                             }
1030                         }
1031                       else
1032                         {
1033                           /* 33222222222211111111110000000000
1034                              10987654321098765432109876543210
1035                              xxxxxxxxxxxxxxxxxxxxxxx10100x1xx
1036                              movk.  */
1037                           return 780;
1038                         }
1039                     }
1040                 }
1041               else
1042                 {
1043                   if (((word >> 21) & 0x1) == 0)
1044                     {
1045                       if (((word >> 28) & 0x1) == 0)
1046                         {
1047                           if (((word >> 29) & 0x1) == 0)
1048                             {
1049                               if (((word >> 30) & 0x1) == 0)
1050                                 {
1051                                   /* 33222222222211111111110000000000
1052                                      10987654321098765432109876543210
1053                                      xxxxxxxxxxxxxxxxxxxxx0xx0101000x
1054                                      and.  */
1055                                   return 764;
1056                                 }
1057                               else
1058                                 {
1059                                   /* 33222222222211111111110000000000
1060                                      10987654321098765432109876543210
1061                                      xxxxxxxxxxxxxxxxxxxxx0xx0101001x
1062                                      eor.  */
1063                                   return 771;
1064                                 }
1065                             }
1066                           else
1067                             {
1068                               if (((word >> 30) & 0x1) == 0)
1069                                 {
1070                                   /* 33222222222211111111110000000000
1071                                      10987654321098765432109876543210
1072                                      xxxxxxxxxxxxxxxxxxxxx0xx0101010x
1073                                      orr.  */
1074                                   return 766;
1075                                 }
1076                               else
1077                                 {
1078                                   /* 33222222222211111111110000000000
1079                                      10987654321098765432109876543210
1080                                      xxxxxxxxxxxxxxxxxxxxx0xx0101011x
1081                                      ands.  */
1082                                   return 773;
1083                                 }
1084                             }
1085                         }
1086                       else
1087                         {
1088                           if (((word >> 10) & 0x1) == 0)
1089                             {
1090                               if (((word >> 11) & 0x1) == 0)
1091                                 {
1092                                   if (((word >> 22) & 0x1) == 0)
1093                                     {
1094                                       if (((word >> 23) & 0x1) == 0)
1095                                         {
1096                                           if (((word >> 29) & 0x1) == 0)
1097                                             {
1098                                               if (((word >> 30) & 0x1) == 0)
1099                                                 {
1100                                                   /* 33222222222211111111110000000000
1101                                                      10987654321098765432109876543210
1102                                                      xxxxxxxxxx00xxxxxxxxx0000101100x
1103                                                      adc.  */
1104                                                   return 0;
1105                                                 }
1106                                               else
1107                                                 {
1108                                                   /* 33222222222211111111110000000000
1109                                                      10987654321098765432109876543210
1110                                                      xxxxxxxxxx00xxxxxxxxx0000101101x
1111                                                      sbc.  */
1112                                                   return 2;
1113                                                 }
1114                                             }
1115                                           else
1116                                             {
1117                                               if (((word >> 30) & 0x1) == 0)
1118                                                 {
1119                                                   /* 33222222222211111111110000000000
1120                                                      10987654321098765432109876543210
1121                                                      xxxxxxxxxx00xxxxxxxxx0000101110x
1122                                                      adcs.  */
1123                                                   return 1;
1124                                                 }
1125                                               else
1126                                                 {
1127                                                   /* 33222222222211111111110000000000
1128                                                      10987654321098765432109876543210
1129                                                      xxxxxxxxxx00xxxxxxxxx0000101111x
1130                                                      sbcs.  */
1131                                                   return 4;
1132                                                 }
1133                                             }
1134                                         }
1135                                       else
1136                                         {
1137                                           if (((word >> 30) & 0x1) == 0)
1138                                             {
1139                                               /* 33222222222211111111110000000000
1140                                                  10987654321098765432109876543210
1141                                                  xxxxxxxxxx00xxxxxxxxx00101011x0x
1142                                                  csel.  */
1143                                               return 524;
1144                                             }
1145                                           else
1146                                             {
1147                                               /* 33222222222211111111110000000000
1148                                                  10987654321098765432109876543210
1149                                                  xxxxxxxxxx00xxxxxxxxx00101011x1x
1150                                                  csinv.  */
1151                                               return 528;
1152                                             }
1153                                         }
1154                                     }
1155                                   else
1156                                     {
1157                                       if (((word >> 23) & 0x1) == 0)
1158                                         {
1159                                           if (((word >> 30) & 0x1) == 0)
1160                                             {
1161                                               /* 33222222222211111111110000000000
1162                                                  10987654321098765432109876543210
1163                                                  xxxxxxxxxx00xxxxxxxxx01001011x0x
1164                                                  ccmn.  */
1165                                               return 522;
1166                                             }
1167                                           else
1168                                             {
1169                                               /* 33222222222211111111110000000000
1170                                                  10987654321098765432109876543210
1171                                                  xxxxxxxxxx00xxxxxxxxx01001011x1x
1172                                                  ccmp.  */
1173                                               return 523;
1174                                             }
1175                                         }
1176                                       else
1177                                         {
1178                                           if (((word >> 12) & 0x1) == 0)
1179                                             {
1180                                               if (((word >> 13) & 0x1) == 0)
1181                                                 {
1182                                                   if (((word >> 14) & 0x1) == 0)
1183                                                     {
1184                                                       /* 33222222222211111111110000000000
1185                                                          10987654321098765432109876543210
1186                                                          xxxxxxxxxx00000xxxxxx01101011xxx
1187                                                          rbit.  */
1188                                                       return 547;
1189                                                     }
1190                                                   else
1191                                                     {
1192                                                       /* 33222222222211111111110000000000
1193                                                          10987654321098765432109876543210
1194                                                          xxxxxxxxxx00001xxxxxx01101011xxx
1195                                                          crc32b.  */
1196                                                       return 564;
1197                                                     }
1198                                                 }
1199                                               else
1200                                                 {
1201                                                   /* 33222222222211111111110000000000
1202                                                      10987654321098765432109876543210
1203                                                      xxxxxxxxxx0001xxxxxxx01101011xxx
1204                                                      lslv.  */
1205                                                   return 556;
1206                                                 }
1207                                             }
1208                                           else
1209                                             {
1210                                               if (((word >> 14) & 0x1) == 0)
1211                                                 {
1212                                                   /* 33222222222211111111110000000000
1213                                                      10987654321098765432109876543210
1214                                                      xxxxxxxxxx001x0xxxxxx01101011xxx
1215                                                      clz.  */
1216                                                   return 551;
1217                                                 }
1218                                               else
1219                                                 {
1220                                                   /* 33222222222211111111110000000000
1221                                                      10987654321098765432109876543210
1222                                                      xxxxxxxxxx001x1xxxxxx01101011xxx
1223                                                      crc32cb.  */
1224                                                   return 568;
1225                                                 }
1226                                             }
1227                                         }
1228                                     }
1229                                 }
1230                               else
1231                                 {
1232                                   if (((word >> 23) & 0x1) == 0)
1233                                     {
1234                                       if (((word >> 30) & 0x1) == 0)
1235                                         {
1236                                           /* 33222222222211111111110000000000
1237                                              10987654321098765432109876543210
1238                                              xxxxxxxxxx01xxxxxxxxx0x001011x0x
1239                                              ccmn.  */
1240                                           return 520;
1241                                         }
1242                                       else
1243                                         {
1244                                           /* 33222222222211111111110000000000
1245                                              10987654321098765432109876543210
1246                                              xxxxxxxxxx01xxxxxxxxx0x001011x1x
1247                                              ccmp.  */
1248                                           return 521;
1249                                         }
1250                                     }
1251                                   else
1252                                     {
1253                                       if (((word >> 12) & 0x1) == 0)
1254                                         {
1255                                           if (((word >> 13) & 0x1) == 0)
1256                                             {
1257                                               if (((word >> 14) & 0x1) == 0)
1258                                                 {
1259                                                   if (((word >> 30) & 0x1) == 0)
1260                                                     {
1261                                                       /* 33222222222211111111110000000000
1262                                                          10987654321098765432109876543210
1263                                                          xxxxxxxxxx01000xxxxxx0x101011x0x
1264                                                          udiv.  */
1265                                                       return 554;
1266                                                     }
1267                                                   else
1268                                                     {
1269                                                       if (((word >> 31) & 0x1) == 0)
1270                                                         {
1271                                                           /* 33222222222211111111110000000000
1272                                                              10987654321098765432109876543210
1273                                                              xxxxxxxxxx01000xxxxxx0x101011x10
1274                                                              rev.  */
1275                                                           return 549;
1276                                                         }
1277                                                       else
1278                                                         {
1279                                                           /* 33222222222211111111110000000000
1280                                                              10987654321098765432109876543210
1281                                                              xxxxxxxxxx01000xxxxxx0x101011x11
1282                                                              rev32.  */
1283                                                           return 553;
1284                                                         }
1285                                                     }
1286                                                 }
1287                                               else
1288                                                 {
1289                                                   /* 33222222222211111111110000000000
1290                                                      10987654321098765432109876543210
1291                                                      xxxxxxxxxx01001xxxxxx0x101011xxx
1292                                                      crc32w.  */
1293                                                   return 566;
1294                                                 }
1295                                             }
1296                                           else
1297                                             {
1298                                               /* 33222222222211111111110000000000
1299                                                  10987654321098765432109876543210
1300                                                  xxxxxxxxxx0101xxxxxxx0x101011xxx
1301                                                  asrv.  */
1302                                               return 560;
1303                                             }
1304                                         }
1305                                       else
1306                                         {
1307                                           /* 33222222222211111111110000000000
1308                                              10987654321098765432109876543210
1309                                              xxxxxxxxxx011xxxxxxxx0x101011xxx
1310                                              crc32cw.  */
1311                                           return 570;
1312                                         }
1313                                     }
1314                                 }
1315                             }
1316                           else
1317                             {
1318                               if (((word >> 11) & 0x1) == 0)
1319                                 {
1320                                   if (((word >> 22) & 0x1) == 0)
1321                                     {
1322                                       if (((word >> 30) & 0x1) == 0)
1323                                         {
1324                                           /* 33222222222211111111110000000000
1325                                              10987654321098765432109876543210
1326                                              xxxxxxxxxx10xxxxxxxxx00x01011x0x
1327                                              csinc.  */
1328                                           return 525;
1329                                         }
1330                                       else
1331                                         {
1332                                           /* 33222222222211111111110000000000
1333                                              10987654321098765432109876543210
1334                                              xxxxxxxxxx10xxxxxxxxx00x01011x1x
1335                                              csneg.  */
1336                                           return 531;
1337                                         }
1338                                     }
1339                                   else
1340                                     {
1341                                       if (((word >> 12) & 0x1) == 0)
1342                                         {
1343                                           if (((word >> 13) & 0x1) == 0)
1344                                             {
1345                                               if (((word >> 14) & 0x1) == 0)
1346                                                 {
1347                                                   /* 33222222222211111111110000000000
1348                                                      10987654321098765432109876543210
1349                                                      xxxxxxxxxx10000xxxxxx01x01011xxx
1350                                                      rev16.  */
1351                                                   return 548;
1352                                                 }
1353                                               else
1354                                                 {
1355                                                   /* 33222222222211111111110000000000
1356                                                      10987654321098765432109876543210
1357                                                      xxxxxxxxxx10001xxxxxx01x01011xxx
1358                                                      crc32h.  */
1359                                                   return 565;
1360                                                 }
1361                                             }
1362                                           else
1363                                             {
1364                                               /* 33222222222211111111110000000000
1365                                                  10987654321098765432109876543210
1366                                                  xxxxxxxxxx1001xxxxxxx01x01011xxx
1367                                                  lsrv.  */
1368                                               return 558;
1369                                             }
1370                                         }
1371                                       else
1372                                         {
1373                                           if (((word >> 14) & 0x1) == 0)
1374                                             {
1375                                               /* 33222222222211111111110000000000
1376                                                  10987654321098765432109876543210
1377                                                  xxxxxxxxxx101x0xxxxxx01x01011xxx
1378                                                  cls.  */
1379                                               return 552;
1380                                             }
1381                                           else
1382                                             {
1383                                               /* 33222222222211111111110000000000
1384                                                  10987654321098765432109876543210
1385                                                  xxxxxxxxxx101x1xxxxxx01x01011xxx
1386                                                  crc32ch.  */
1387                                               return 569;
1388                                             }
1389                                         }
1390                                     }
1391                                 }
1392                               else
1393                                 {
1394                                   if (((word >> 12) & 0x1) == 0)
1395                                     {
1396                                       if (((word >> 13) & 0x1) == 0)
1397                                         {
1398                                           if (((word >> 14) & 0x1) == 0)
1399                                             {
1400                                               if (((word >> 30) & 0x1) == 0)
1401                                                 {
1402                                                   /* 33222222222211111111110000000000
1403                                                      10987654321098765432109876543210
1404                                                      xxxxxxxxxx11000xxxxxx0xx01011x0x
1405                                                      sdiv.  */
1406                                                   return 555;
1407                                                 }
1408                                               else
1409                                                 {
1410                                                   /* 33222222222211111111110000000000
1411                                                      10987654321098765432109876543210
1412                                                      xxxxxxxxxx11000xxxxxx0xx01011x1x
1413                                                      rev.  */
1414                                                   return 550;
1415                                                 }
1416                                             }
1417                                           else
1418                                             {
1419                                               /* 33222222222211111111110000000000
1420                                                  10987654321098765432109876543210
1421                                                  xxxxxxxxxx11001xxxxxx0xx01011xxx
1422                                                  crc32x.  */
1423                                               return 567;
1424                                             }
1425                                         }
1426                                       else
1427                                         {
1428                                           /* 33222222222211111111110000000000
1429                                              10987654321098765432109876543210
1430                                              xxxxxxxxxx1101xxxxxxx0xx01011xxx
1431                                              rorv.  */
1432                                           return 562;
1433                                         }
1434                                     }
1435                                   else
1436                                     {
1437                                       /* 33222222222211111111110000000000
1438                                          10987654321098765432109876543210
1439                                          xxxxxxxxxx111xxxxxxxx0xx01011xxx
1440                                          crc32cx.  */
1441                                       return 571;
1442                                     }
1443                                 }
1444                             }
1445                         }
1446                     }
1447                   else
1448                     {
1449                       if (((word >> 29) & 0x1) == 0)
1450                         {
1451                           if (((word >> 30) & 0x1) == 0)
1452                             {
1453                               /* 33222222222211111111110000000000
1454                                  10987654321098765432109876543210
1455                                  xxxxxxxxxxxxxxxxxxxxx1xx0101x00x
1456                                  bic.  */
1457                               return 765;
1458                             }
1459                           else
1460                             {
1461                               /* 33222222222211111111110000000000
1462                                  10987654321098765432109876543210
1463                                  xxxxxxxxxxxxxxxxxxxxx1xx0101x01x
1464                                  eon.  */
1465                               return 772;
1466                             }
1467                         }
1468                       else
1469                         {
1470                           if (((word >> 30) & 0x1) == 0)
1471                             {
1472                               /* 33222222222211111111110000000000
1473                                  10987654321098765432109876543210
1474                                  xxxxxxxxxxxxxxxxxxxxx1xx0101x10x
1475                                  orn.  */
1476                               return 769;
1477                             }
1478                           else
1479                             {
1480                               /* 33222222222211111111110000000000
1481                                  10987654321098765432109876543210
1482                                  xxxxxxxxxxxxxxxxxxxxx1xx0101x11x
1483                                  bics.  */
1484                               return 775;
1485                             }
1486                         }
1487                     }
1488                 }
1489             }
1490           else
1491             {
1492               if (((word >> 27) & 0x1) == 0)
1493                 {
1494                   if (((word >> 23) & 0x1) == 0)
1495                     {
1496                       if (((word >> 29) & 0x1) == 0)
1497                         {
1498                           if (((word >> 30) & 0x1) == 0)
1499                             {
1500                               /* 33222222222211111111110000000000
1501                                  10987654321098765432109876543210
1502                                  xxxxxxxxxxxxxxxxxxxxxxx01100x00x
1503                                  sbfm.  */
1504                               return 493;
1505                             }
1506                           else
1507                             {
1508                               /* 33222222222211111111110000000000
1509                                  10987654321098765432109876543210
1510                                  xxxxxxxxxxxxxxxxxxxxxxx01100x01x
1511                                  ubfm.  */
1512                               return 503;
1513                             }
1514                         }
1515                       else
1516                         {
1517                           /* 33222222222211111111110000000000
1518                              10987654321098765432109876543210
1519                              xxxxxxxxxxxxxxxxxxxxxxx01100x1xx
1520                              bfm.  */
1521                           return 500;
1522                         }
1523                     }
1524                   else
1525                     {
1526                       /* 33222222222211111111110000000000
1527                          10987654321098765432109876543210
1528                          xxxxxxxxxxxxxxxxxxxxxxx11100xxxx
1529                          extr.  */
1530                       return 594;
1531                     }
1532                 }
1533               else
1534                 {
1535                   if (((word >> 21) & 0x1) == 0)
1536                     {
1537                       if (((word >> 28) & 0x1) == 0)
1538                         {
1539                           if (((word >> 29) & 0x1) == 0)
1540                             {
1541                               if (((word >> 30) & 0x1) == 0)
1542                                 {
1543                                   /* 33222222222211111111110000000000
1544                                      10987654321098765432109876543210
1545                                      xxxxxxxxxxxxxxxxxxxxx0xx1101000x
1546                                      add.  */
1547                                   return 19;
1548                                 }
1549                               else
1550                                 {
1551                                   /* 33222222222211111111110000000000
1552                                      10987654321098765432109876543210
1553                                      xxxxxxxxxxxxxxxxxxxxx0xx1101001x
1554                                      sub.  */
1555                                   return 22;
1556                                 }
1557                             }
1558                           else
1559                             {
1560                               if (((word >> 30) & 0x1) == 0)
1561                                 {
1562                                   /* 33222222222211111111110000000000
1563                                      10987654321098765432109876543210
1564                                      xxxxxxxxxxxxxxxxxxxxx0xx1101010x
1565                                      adds.  */
1566                                   return 20;
1567                                 }
1568                               else
1569                                 {
1570                                   /* 33222222222211111111110000000000
1571                                      10987654321098765432109876543210
1572                                      xxxxxxxxxxxxxxxxxxxxx0xx1101011x
1573                                      subs.  */
1574                                   return 24;
1575                                 }
1576                             }
1577                         }
1578                       else
1579                         {
1580                           if (((word >> 15) & 0x1) == 0)
1581                             {
1582                               if (((word >> 22) & 0x1) == 0)
1583                                 {
1584                                   /* 33222222222211111111110000000000
1585                                      10987654321098765432109876543210
1586                                      xxxxxxxxxxxxxxx0xxxxx00x11011xxx
1587                                      madd.  */
1588                                   return 572;
1589                                 }
1590                               else
1591                                 {
1592                                   if (((word >> 23) & 0x1) == 0)
1593                                     {
1594                                       /* 33222222222211111111110000000000
1595                                          10987654321098765432109876543210
1596                                          xxxxxxxxxxxxxxx0xxxxx01011011xxx
1597                                          smulh.  */
1598                                       return 580;
1599                                     }
1600                                   else
1601                                     {
1602                                       /* 33222222222211111111110000000000
1603                                          10987654321098765432109876543210
1604                                          xxxxxxxxxxxxxxx0xxxxx01111011xxx
1605                                          umulh.  */
1606                                       return 585;
1607                                     }
1608                                 }
1609                             }
1610                           else
1611                             {
1612                               /* 33222222222211111111110000000000
1613                                  10987654321098765432109876543210
1614                                  xxxxxxxxxxxxxxx1xxxxx0xx11011xxx
1615                                  msub.  */
1616                               return 574;
1617                             }
1618                         }
1619                     }
1620                   else
1621                     {
1622                       if (((word >> 23) & 0x1) == 0)
1623                         {
1624                           if (((word >> 28) & 0x1) == 0)
1625                             {
1626                               if (((word >> 29) & 0x1) == 0)
1627                                 {
1628                                   if (((word >> 30) & 0x1) == 0)
1629                                     {
1630                                       /* 33222222222211111111110000000000
1631                                          10987654321098765432109876543210
1632                                          xxxxxxxxxxxxxxxxxxxxx1x01101000x
1633                                          add.  */
1634                                       return 6;
1635                                     }
1636                                   else
1637                                     {
1638                                       /* 33222222222211111111110000000000
1639                                          10987654321098765432109876543210
1640                                          xxxxxxxxxxxxxxxxxxxxx1x01101001x
1641                                          sub.  */
1642                                       return 9;
1643                                     }
1644                                 }
1645                               else
1646                                 {
1647                                   if (((word >> 30) & 0x1) == 0)
1648                                     {
1649                                       /* 33222222222211111111110000000000
1650                                          10987654321098765432109876543210
1651                                          xxxxxxxxxxxxxxxxxxxxx1x01101010x
1652                                          adds.  */
1653                                       return 7;
1654                                     }
1655                                   else
1656                                     {
1657                                       /* 33222222222211111111110000000000
1658                                          10987654321098765432109876543210
1659                                          xxxxxxxxxxxxxxxxxxxxx1x01101011x
1660                                          subs.  */
1661                                       return 10;
1662                                     }
1663                                 }
1664                             }
1665                           else
1666                             {
1667                               if (((word >> 15) & 0x1) == 0)
1668                                 {
1669                                   /* 33222222222211111111110000000000
1670                                      10987654321098765432109876543210
1671                                      xxxxxxxxxxxxxxx0xxxxx1x011011xxx
1672                                      smaddl.  */
1673                                   return 576;
1674                                 }
1675                               else
1676                                 {
1677                                   /* 33222222222211111111110000000000
1678                                      10987654321098765432109876543210
1679                                      xxxxxxxxxxxxxxx1xxxxx1x011011xxx
1680                                      smsubl.  */
1681                                   return 578;
1682                                 }
1683                             }
1684                         }
1685                       else
1686                         {
1687                           if (((word >> 15) & 0x1) == 0)
1688                             {
1689                               /* 33222222222211111111110000000000
1690                                  10987654321098765432109876543210
1691                                  xxxxxxxxxxxxxxx0xxxxx1x11101xxxx
1692                                  umaddl.  */
1693                               return 581;
1694                             }
1695                           else
1696                             {
1697                               /* 33222222222211111111110000000000
1698                                  10987654321098765432109876543210
1699                                  xxxxxxxxxxxxxxx1xxxxx1x11101xxxx
1700                                  umsubl.  */
1701                               return 583;
1702                             }
1703                         }
1704                     }
1705                 }
1706             }
1707         }
1708     }
1709   else
1710     {
1711       if (((word >> 27) & 0x1) == 0)
1712         {
1713           if (((word >> 29) & 0x1) == 0)
1714             {
1715               if (((word >> 30) & 0x1) == 0)
1716                 {
1717                   if (((word >> 31) & 0x1) == 0)
1718                     {
1719                       /* 33222222222211111111110000000000
1720                          10987654321098765432109876543210
1721                          xxxxxxxxxxxxxxxxxxxxxxxxxx10x000
1722                          b.  */
1723                       return 510;
1724                     }
1725                   else
1726                     {
1727                       /* 33222222222211111111110000000000
1728                          10987654321098765432109876543210
1729                          xxxxxxxxxxxxxxxxxxxxxxxxxx10x001
1730                          bl.  */
1731                       return 511;
1732                     }
1733                 }
1734               else
1735                 {
1736                   if (((word >> 24) & 0x1) == 0)
1737                     {
1738                       if (((word >> 25) & 0x1) == 0)
1739                         {
1740                           if (((word >> 31) & 0x1) == 0)
1741                             {
1742                               /* 33222222222211111111110000000000
1743                                  10987654321098765432109876543210
1744                                  xxxxxxxxxxxxxxxxxxxxxxxx0010x010
1745                                  b.c.  */
1746                               return 519;
1747                             }
1748                           else
1749                             {
1750                               if (((word >> 0) & 0x1) == 0)
1751                                 {
1752                                   if (((word >> 1) & 0x1) == 0)
1753                                     {
1754                                       if (((word >> 21) & 0x1) == 0)
1755                                         {
1756                                           /* 33222222222211111111110000000000
1757                                              10987654321098765432109876543210
1758                                              00xxxxxxxxxxxxxxxxxxx0xx0010x011
1759                                              hlt.  */
1760                                           return 590;
1761                                         }
1762                                       else
1763                                         {
1764                                           /* 33222222222211111111110000000000
1765                                              10987654321098765432109876543210
1766                                              00xxxxxxxxxxxxxxxxxxx1xx0010x011
1767                                              brk.  */
1768                                           return 589;
1769                                         }
1770                                     }
1771                                   else
1772                                     {
1773                                       if (((word >> 21) & 0x1) == 0)
1774                                         {
1775                                           /* 33222222222211111111110000000000
1776                                              10987654321098765432109876543210
1777                                              01xxxxxxxxxxxxxxxxxxx0xx0010x011
1778                                              hvc.  */
1779                                           return 587;
1780                                         }
1781                                       else
1782                                         {
1783                                           /* 33222222222211111111110000000000
1784                                              10987654321098765432109876543210
1785                                              01xxxxxxxxxxxxxxxxxxx1xx0010x011
1786                                              dcps2.  */
1787                                           return 592;
1788                                         }
1789                                     }
1790                                 }
1791                               else
1792                                 {
1793                                   if (((word >> 1) & 0x1) == 0)
1794                                     {
1795                                       if (((word >> 21) & 0x1) == 0)
1796                                         {
1797                                           /* 33222222222211111111110000000000
1798                                              10987654321098765432109876543210
1799                                              10xxxxxxxxxxxxxxxxxxx0xx0010x011
1800                                              svc.  */
1801                                           return 586;
1802                                         }
1803                                       else
1804                                         {
1805                                           /* 33222222222211111111110000000000
1806                                              10987654321098765432109876543210
1807                                              10xxxxxxxxxxxxxxxxxxx1xx0010x011
1808                                              dcps1.  */
1809                                           return 591;
1810                                         }
1811                                     }
1812                                   else
1813                                     {
1814                                       if (((word >> 21) & 0x1) == 0)
1815                                         {
1816                                           /* 33222222222211111111110000000000
1817                                              10987654321098765432109876543210
1818                                              11xxxxxxxxxxxxxxxxxxx0xx0010x011
1819                                              smc.  */
1820                                           return 588;
1821                                         }
1822                                       else
1823                                         {
1824                                           /* 33222222222211111111110000000000
1825                                              10987654321098765432109876543210
1826                                              11xxxxxxxxxxxxxxxxxxx1xx0010x011
1827                                              dcps3.  */
1828                                           return 593;
1829                                         }
1830                                     }
1831                                 }
1832                             }
1833                         }
1834                       else
1835                         {
1836                           if (((word >> 21) & 0x1) == 0)
1837                             {
1838                               if (((word >> 22) & 0x1) == 0)
1839                                 {
1840                                   if (((word >> 23) & 0x1) == 0)
1841                                     {
1842                                       /* 33222222222211111111110000000000
1843                                          10987654321098765432109876543210
1844                                          xxxxxxxxxxxxxxxxxxxxx0000110x01x
1845                                          br.  */
1846                                       return 512;
1847                                     }
1848                                   else
1849                                     {
1850                                       /* 33222222222211111111110000000000
1851                                          10987654321098765432109876543210
1852                                          xxxxxxxxxxxxxxxxxxxxx0010110x01x
1853                                          eret.  */
1854                                       return 515;
1855                                     }
1856                                 }
1857                               else
1858                                 {
1859                                   /* 33222222222211111111110000000000
1860                                      10987654321098765432109876543210
1861                                      xxxxxxxxxxxxxxxxxxxxx01x0110x01x
1862                                      ret.  */
1863                                   return 514;
1864                                 }
1865                             }
1866                           else
1867                             {
1868                               if (((word >> 23) & 0x1) == 0)
1869                                 {
1870                                   /* 33222222222211111111110000000000
1871                                      10987654321098765432109876543210
1872                                      xxxxxxxxxxxxxxxxxxxxx1x00110x01x
1873                                      blr.  */
1874                                   return 513;
1875                                 }
1876                               else
1877                                 {
1878                                   /* 33222222222211111111110000000000
1879                                      10987654321098765432109876543210
1880                                      xxxxxxxxxxxxxxxxxxxxx1x10110x01x
1881                                      drps.  */
1882                                   return 516;
1883                                 }
1884                             }
1885                         }
1886                     }
1887                   else
1888                     {
1889                       if (((word >> 20) & 0x1) == 0)
1890                         {
1891                           if (((word >> 19) & 0x1) == 0)
1892                             {
1893                               if (((word >> 12) & 0x1) == 0)
1894                                 {
1895                                   if (((word >> 13) & 0x1) == 0)
1896                                     {
1897                                       /* 33222222222211111111110000000000
1898                                          10987654321098765432109876543210
1899                                          xxxxxxxxxxxx00xxxxx00xxx1x10x01x
1900                                          msr.  */
1901                                       return 783;
1902                                     }
1903                                   else
1904                                     {
1905                                       /* 33222222222211111111110000000000
1906                                          10987654321098765432109876543210
1907                                          xxxxxxxxxxxx01xxxxx00xxx1x10x01x
1908                                          hint.  */
1909                                       return 784;
1910                                     }
1911                                 }
1912                               else
1913                                 {
1914                                   if (((word >> 5) & 0x1) == 0)
1915                                     {
1916                                       if (((word >> 6) & 0x1) == 0)
1917                                         {
1918                                           /* 33222222222211111111110000000000
1919                                              10987654321098765432109876543210
1920                                              xxxxx00xxxxx1xxxxxx00xxx1x10x01x
1921                                              dsb.  */
1922                                           return 792;
1923                                         }
1924                                       else
1925                                         {
1926                                           if (((word >> 7) & 0x1) == 0)
1927                                             {
1928                                               /* 33222222222211111111110000000000
1929                                                  10987654321098765432109876543210
1930                                                  xxxxx010xxxx1xxxxxx00xxx1x10x01x
1931                                                  clrex.  */
1932                                               return 791;
1933                                             }
1934                                           else
1935                                             {
1936                                               /* 33222222222211111111110000000000
1937                                                  10987654321098765432109876543210
1938                                                  xxxxx011xxxx1xxxxxx00xxx1x10x01x
1939                                                  isb.  */
1940                                               return 794;
1941                                             }
1942                                         }
1943                                     }
1944                                   else
1945                                     {
1946                                       /* 33222222222211111111110000000000
1947                                          10987654321098765432109876543210
1948                                          xxxxx1xxxxxx1xxxxxx00xxx1x10x01x
1949                                          dmb.  */
1950                                       return 793;
1951                                     }
1952                                 }
1953                             }
1954                           else
1955                             {
1956                               if (((word >> 21) & 0x1) == 0)
1957                                 {
1958                                   /* 33222222222211111111110000000000
1959                                      10987654321098765432109876543210
1960                                      xxxxxxxxxxxxxxxxxxx100xx1x10x01x
1961                                      sys.  */
1962                                   return 795;
1963                                 }
1964                               else
1965                                 {
1966                                   /* 33222222222211111111110000000000
1967                                      10987654321098765432109876543210
1968                                      xxxxxxxxxxxxxxxxxxx101xx1x10x01x
1969                                      sysl.  */
1970                                   return 801;
1971                                 }
1972                             }
1973                         }
1974                       else
1975                         {
1976                           if (((word >> 21) & 0x1) == 0)
1977                             {
1978                               /* 33222222222211111111110000000000
1979                                  10987654321098765432109876543210
1980                                  xxxxxxxxxxxxxxxxxxxx10xx1x10x01x
1981                                  msr.  */
1982                               return 800;
1983                             }
1984                           else
1985                             {
1986                               /* 33222222222211111111110000000000
1987                                  10987654321098765432109876543210
1988                                  xxxxxxxxxxxxxxxxxxxx11xx1x10x01x
1989                                  mrs.  */
1990                               return 802;
1991                             }
1992                         }
1993                     }
1994                 }
1995             }
1996           else
1997             {
1998               if (((word >> 24) & 0x1) == 0)
1999                 {
2000                   if (((word >> 25) & 0x1) == 0)
2001                     {
2002                       /* 33222222222211111111110000000000
2003                          10987654321098765432109876543210
2004                          xxxxxxxxxxxxxxxxxxxxxxxx0010x1xx
2005                          cbz.  */
2006                       return 517;
2007                     }
2008                   else
2009                     {
2010                       /* 33222222222211111111110000000000
2011                          10987654321098765432109876543210
2012                          xxxxxxxxxxxxxxxxxxxxxxxx0110x1xx
2013                          tbz.  */
2014                       return 803;
2015                     }
2016                 }
2017               else
2018                 {
2019                   if (((word >> 25) & 0x1) == 0)
2020                     {
2021                       /* 33222222222211111111110000000000
2022                          10987654321098765432109876543210
2023                          xxxxxxxxxxxxxxxxxxxxxxxx1010x1xx
2024                          cbnz.  */
2025                       return 518;
2026                     }
2027                   else
2028                     {
2029                       /* 33222222222211111111110000000000
2030                          10987654321098765432109876543210
2031                          xxxxxxxxxxxxxxxxxxxxxxxx1110x1xx
2032                          tbnz.  */
2033                       return 804;
2034                     }
2035                 }
2036             }
2037         }
2038       else
2039         {
2040           if (((word >> 25) & 0x1) == 0)
2041             {
2042               if (((word >> 28) & 0x1) == 0)
2043                 {
2044                   if (((word >> 22) & 0x1) == 0)
2045                     {
2046                       if (((word >> 23) & 0x1) == 0)
2047                         {
2048                           if (((word >> 24) & 0x1) == 0)
2049                             {
2050                               if (((word >> 29) & 0x1) == 0)
2051                                 {
2052                                   /* 33222222222211111111110000000000
2053                                      10987654321098765432109876543210
2054                                      xxxxxxxxxxxxxxxxxxxxxx00001100xx
2055                                      st4.  */
2056                                   return 355;
2057                                 }
2058                               else
2059                                 {
2060                                   /* 33222222222211111111110000000000
2061                                      10987654321098765432109876543210
2062                                      xxxxxxxxxxxxxxxxxxxxxx00001101xx
2063                                      stnp.  */
2064                                   return 741;
2065                                 }
2066                             }
2067                           else
2068                             {
2069                               if (((word >> 29) & 0x1) == 0)
2070                                 {
2071                                   if (((word >> 13) & 0x1) == 0)
2072                                     {
2073                                       if (((word >> 21) & 0x1) == 0)
2074                                         {
2075                                           /* 33222222222211111111110000000000
2076                                              10987654321098765432109876543210
2077                                              xxxxxxxxxxxxx0xxxxxxx000101100xx
2078                                              st1.  */
2079                                           return 371;
2080                                         }
2081                                       else
2082                                         {
2083                                           /* 33222222222211111111110000000000
2084                                              10987654321098765432109876543210
2085                                              xxxxxxxxxxxxx0xxxxxxx100101100xx
2086                                              st2.  */
2087                                           return 373;
2088                                         }
2089                                     }
2090                                   else
2091                                     {
2092                                       if (((word >> 21) & 0x1) == 0)
2093                                         {
2094                                           /* 33222222222211111111110000000000
2095                                              10987654321098765432109876543210
2096                                              xxxxxxxxxxxxx1xxxxxxx000101100xx
2097                                              st3.  */
2098                                           return 372;
2099                                         }
2100                                       else
2101                                         {
2102                                           /* 33222222222211111111110000000000
2103                                              10987654321098765432109876543210
2104                                              xxxxxxxxxxxxx1xxxxxxx100101100xx
2105                                              st4.  */
2106                                           return 374;
2107                                         }
2108                                     }
2109                                 }
2110                               else
2111                                 {
2112                                   /* 33222222222211111111110000000000
2113                                      10987654321098765432109876543210
2114                                      xxxxxxxxxxxxxxxxxxxxxx00101101xx
2115                                      stp.  */
2116                                   return 745;
2117                                 }
2118                             }
2119                         }
2120                       else
2121                         {
2122                           if (((word >> 29) & 0x1) == 0)
2123                             {
2124                               if (((word >> 21) & 0x1) == 0)
2125                                 {
2126                                   if (((word >> 24) & 0x1) == 0)
2127                                     {
2128                                       /* 33222222222211111111110000000000
2129                                          10987654321098765432109876543210
2130                                          xxxxxxxxxxxxxxxxxxxxx001001100xx
2131                                          st4.  */
2132                                       return 363;
2133                                     }
2134                                   else
2135                                     {
2136                                       if (((word >> 13) & 0x1) == 0)
2137                                         {
2138                                           /* 33222222222211111111110000000000
2139                                              10987654321098765432109876543210
2140                                              xxxxxxxxxxxxx0xxxxxxx001101100xx
2141                                              st1.  */
2142                                           return 383;
2143                                         }
2144                                       else
2145                                         {
2146                                           /* 33222222222211111111110000000000
2147                                              10987654321098765432109876543210
2148                                              xxxxxxxxxxxxx1xxxxxxx001101100xx
2149                                              st3.  */
2150                                           return 384;
2151                                         }
2152                                     }
2153                                 }
2154                               else
2155                                 {
2156                                   if (((word >> 13) & 0x1) == 0)
2157                                     {
2158                                       /* 33222222222211111111110000000000
2159                                          10987654321098765432109876543210
2160                                          xxxxxxxxxxxxx0xxxxxxx101x01100xx
2161                                          st2.  */
2162                                       return 385;
2163                                     }
2164                                   else
2165                                     {
2166                                       /* 33222222222211111111110000000000
2167                                          10987654321098765432109876543210
2168                                          xxxxxxxxxxxxx1xxxxxxx101x01100xx
2169                                          st4.  */
2170                                       return 386;
2171                                     }
2172                                 }
2173                             }
2174                           else
2175                             {
2176                               /* 33222222222211111111110000000000
2177                                  10987654321098765432109876543210
2178                                  xxxxxxxxxxxxxxxxxxxxxx01x01101xx
2179                                  stp.  */
2180                               return 750;
2181                             }
2182                         }
2183                     }
2184                   else
2185                     {
2186                       if (((word >> 23) & 0x1) == 0)
2187                         {
2188                           if (((word >> 24) & 0x1) == 0)
2189                             {
2190                               if (((word >> 29) & 0x1) == 0)
2191                                 {
2192                                   /* 33222222222211111111110000000000
2193                                      10987654321098765432109876543210
2194                                      xxxxxxxxxxxxxxxxxxxxxx10001100xx
2195                                      ld4.  */
2196                                   return 359;
2197                                 }
2198                               else
2199                                 {
2200                                   /* 33222222222211111111110000000000
2201                                      10987654321098765432109876543210
2202                                      xxxxxxxxxxxxxxxxxxxxxx10001101xx
2203                                      ldnp.  */
2204                                   return 742;
2205                                 }
2206                             }
2207                           else
2208                             {
2209                               if (((word >> 29) & 0x1) == 0)
2210                                 {
2211                                   if (((word >> 13) & 0x1) == 0)
2212                                     {
2213                                       if (((word >> 21) & 0x1) == 0)
2214                                         {
2215                                           /* 33222222222211111111110000000000
2216                                              10987654321098765432109876543210
2217                                              xxxxxxxxxxxxx0xxxxxxx010101100xx
2218                                              ld1.  */
2219                                           return 375;
2220                                         }
2221                                       else
2222                                         {
2223                                           /* 33222222222211111111110000000000
2224                                              10987654321098765432109876543210
2225                                              xxxxxxxxxxxxx0xxxxxxx110101100xx
2226                                              ld2.  */
2227                                           return 379;
2228                                         }
2229                                     }
2230                                   else
2231                                     {
2232                                       if (((word >> 21) & 0x1) == 0)
2233                                         {
2234                                           /* 33222222222211111111110000000000
2235                                              10987654321098765432109876543210
2236                                              xxxxxxxxxxxxx1xxxxxxx010101100xx
2237                                              ld3.  */
2238                                           return 376;
2239                                         }
2240                                       else
2241                                         {
2242                                           /* 33222222222211111111110000000000
2243                                              10987654321098765432109876543210
2244                                              xxxxxxxxxxxxx1xxxxxxx110101100xx
2245                                              ld4.  */
2246                                           return 380;
2247                                         }
2248                                     }
2249                                 }
2250                               else
2251                                 {
2252                                   /* 33222222222211111111110000000000
2253                                      10987654321098765432109876543210
2254                                      xxxxxxxxxxxxxxxxxxxxxx10101101xx
2255                                      ldp.  */
2256                                   return 746;
2257                                 }
2258                             }
2259                         }
2260                       else
2261                         {
2262                           if (((word >> 29) & 0x1) == 0)
2263                             {
2264                               if (((word >> 21) & 0x1) == 0)
2265                                 {
2266                                   if (((word >> 24) & 0x1) == 0)
2267                                     {
2268                                       /* 33222222222211111111110000000000
2269                                          10987654321098765432109876543210
2270                                          xxxxxxxxxxxxxxxxxxxxx011001100xx
2271                                          ld4.  */
2272                                       return 367;
2273                                     }
2274                                   else
2275                                     {
2276                                       if (((word >> 13) & 0x1) == 0)
2277                                         {
2278                                           /* 33222222222211111111110000000000
2279                                              10987654321098765432109876543210
2280                                              xxxxxxxxxxxxx0xxxxxxx011101100xx
2281                                              ld1.  */
2282                                           return 387;
2283                                         }
2284                                       else
2285                                         {
2286                                           /* 33222222222211111111110000000000
2287                                              10987654321098765432109876543210
2288                                              xxxxxxxxxxxxx1xxxxxxx011101100xx
2289                                              ld3.  */
2290                                           return 388;
2291                                         }
2292                                     }
2293                                 }
2294                               else
2295                                 {
2296                                   if (((word >> 13) & 0x1) == 0)
2297                                     {
2298                                       /* 33222222222211111111110000000000
2299                                          10987654321098765432109876543210
2300                                          xxxxxxxxxxxxx0xxxxxxx111x01100xx
2301                                          ld2.  */
2302                                       return 391;
2303                                     }
2304                                   else
2305                                     {
2306                                       /* 33222222222211111111110000000000
2307                                          10987654321098765432109876543210
2308                                          xxxxxxxxxxxxx1xxxxxxx111x01100xx
2309                                          ld4.  */
2310                                       return 392;
2311                                     }
2312                                 }
2313                             }
2314                           else
2315                             {
2316                               /* 33222222222211111111110000000000
2317                                  10987654321098765432109876543210
2318                                  xxxxxxxxxxxxxxxxxxxxxx11x01101xx
2319                                  ldp.  */
2320                               return 751;
2321                             }
2322                         }
2323                     }
2324                 }
2325               else
2326                 {
2327                   if (((word >> 24) & 0x1) == 0)
2328                     {
2329                       if (((word >> 29) & 0x1) == 0)
2330                         {
2331                           /* 33222222222211111111110000000000
2332                              10987654321098765432109876543210
2333                              xxxxxxxxxxxxxxxxxxxxxxxx001110xx
2334                              ldr.  */
2335                           return 754;
2336                         }
2337                       else
2338                         {
2339                           if (((word >> 10) & 0x1) == 0)
2340                             {
2341                               if (((word >> 11) & 0x1) == 0)
2342                                 {
2343                                   if (((word >> 22) & 0x1) == 0)
2344                                     {
2345                                       /* 33222222222211111111110000000000
2346                                          10987654321098765432109876543210
2347                                          xxxxxxxxxx00xxxxxxxxxx0x001111xx
2348                                          stur.  */
2349                                       return 699;
2350                                     }
2351                                   else
2352                                     {
2353                                       /* 33222222222211111111110000000000
2354                                          10987654321098765432109876543210
2355                                          xxxxxxxxxx00xxxxxxxxxx1x001111xx
2356                                          ldur.  */
2357                                       return 700;
2358                                     }
2359                                 }
2360                               else
2361                                 {
2362                                   if (((word >> 22) & 0x1) == 0)
2363                                     {
2364                                       /* 33222222222211111111110000000000
2365                                          10987654321098765432109876543210
2366                                          xxxxxxxxxx01xxxxxxxxxx0x001111xx
2367                                          str.  */
2368                                       return 675;
2369                                     }
2370                                   else
2371                                     {
2372                                       /* 33222222222211111111110000000000
2373                                          10987654321098765432109876543210
2374                                          xxxxxxxxxx01xxxxxxxxxx1x001111xx
2375                                          ldr.  */
2376                                       return 676;
2377                                     }
2378                                 }
2379                             }
2380                           else
2381                             {
2382                               if (((word >> 22) & 0x1) == 0)
2383                                 {
2384                                   /* 33222222222211111111110000000000
2385                                      10987654321098765432109876543210
2386                                      xxxxxxxxxx1xxxxxxxxxxx0x001111xx
2387                                      str.  */
2388                                   return 652;
2389                                 }
2390                               else
2391                                 {
2392                                   /* 33222222222211111111110000000000
2393                                      10987654321098765432109876543210
2394                                      xxxxxxxxxx1xxxxxxxxxxx1x001111xx
2395                                      ldr.  */
2396                                   return 653;
2397                                 }
2398                             }
2399                         }
2400                     }
2401                   else
2402                     {
2403                       if (((word >> 22) & 0x1) == 0)
2404                         {
2405                           /* 33222222222211111111110000000000
2406                              10987654321098765432109876543210
2407                              xxxxxxxxxxxxxxxxxxxxxx0x10111xxx
2408                              str.  */
2409                           return 663;
2410                         }
2411                       else
2412                         {
2413                           /* 33222222222211111111110000000000
2414                              10987654321098765432109876543210
2415                              xxxxxxxxxxxxxxxxxxxxxx1x10111xxx
2416                              ldr.  */
2417                           return 664;
2418                         }
2419                     }
2420                 }
2421             }
2422           else
2423             {
2424               if (((word >> 24) & 0x1) == 0)
2425                 {
2426                   if (((word >> 21) & 0x1) == 0)
2427                     {
2428                       if (((word >> 28) & 0x1) == 0)
2429                         {
2430                           if (((word >> 10) & 0x1) == 0)
2431                             {
2432                               if (((word >> 29) & 0x1) == 0)
2433                                 {
2434                                   if (((word >> 11) & 0x1) == 0)
2435                                     {
2436                                       if (((word >> 12) & 0x1) == 0)
2437                                         {
2438                                           /* 33222222222211111111110000000000
2439                                              10987654321098765432109876543210
2440                                              xxxxxxxxxx000xxxxxxxx0xx011100xx
2441                                              tbl.  */
2442                                           return 341;
2443                                         }
2444                                       else
2445                                         {
2446                                           /* 33222222222211111111110000000000
2447                                              10987654321098765432109876543210
2448                                              xxxxxxxxxx001xxxxxxxx0xx011100xx
2449                                              tbx.  */
2450                                           return 342;
2451                                         }
2452                                     }
2453                                   else
2454                                     {
2455                                       if (((word >> 12) & 0x1) == 0)
2456                                         {
2457                                           if (((word >> 14) & 0x1) == 0)
2458                                             {
2459                                               /* 33222222222211111111110000000000
2460                                                  10987654321098765432109876543210
2461                                                  xxxxxxxxxx010x0xxxxxx0xx011100xx
2462                                                  trn1.  */
2463                                               return 216;
2464                                             }
2465                                           else
2466                                             {
2467                                               /* 33222222222211111111110000000000
2468                                                  10987654321098765432109876543210
2469                                                  xxxxxxxxxx010x1xxxxxx0xx011100xx
2470                                                  trn2.  */
2471                                               return 219;
2472                                             }
2473                                         }
2474                                       else
2475                                         {
2476                                           if (((word >> 13) & 0x1) == 0)
2477                                             {
2478                                               if (((word >> 14) & 0x1) == 0)
2479                                                 {
2480                                                   /* 33222222222211111111110000000000
2481                                                      10987654321098765432109876543210
2482                                                      xxxxxxxxxx01100xxxxxx0xx011100xx
2483                                                      uzp1.  */
2484                                                   return 215;
2485                                                 }
2486                                               else
2487                                                 {
2488                                                   /* 33222222222211111111110000000000
2489                                                      10987654321098765432109876543210
2490                                                      xxxxxxxxxx01101xxxxxx0xx011100xx
2491                                                      uzp2.  */
2492                                                   return 218;
2493                                                 }
2494                                             }
2495                                           else
2496                                             {
2497                                               if (((word >> 14) & 0x1) == 0)
2498                                                 {
2499                                                   /* 33222222222211111111110000000000
2500                                                      10987654321098765432109876543210
2501                                                      xxxxxxxxxx01110xxxxxx0xx011100xx
2502                                                      zip1.  */
2503                                                   return 217;
2504                                                 }
2505                                               else
2506                                                 {
2507                                                   /* 33222222222211111111110000000000
2508                                                      10987654321098765432109876543210
2509                                                      xxxxxxxxxx01111xxxxxx0xx011100xx
2510                                                      zip2.  */
2511                                                   return 220;
2512                                                 }
2513                                             }
2514                                         }
2515                                     }
2516                                 }
2517                               else
2518                                 {
2519                                   /* 33222222222211111111110000000000
2520                                      10987654321098765432109876543210
2521                                      xxxxxxxxxx0xxxxxxxxxx0xx011101xx
2522                                      ext.  */
2523                                   return 119;
2524                                 }
2525                             }
2526                           else
2527                             {
2528                               if (((word >> 29) & 0x1) == 0)
2529                                 {
2530                                   if (((word >> 11) & 0x1) == 0)
2531                                     {
2532                                       /* 33222222222211111111110000000000
2533                                          10987654321098765432109876543210
2534                                          xxxxxxxxxx10xxxxxxxxx0xx011100xx
2535                                          dup.  */
2536                                       return 135;
2537                                     }
2538                                   else
2539                                     {
2540                                       if (((word >> 12) & 0x1) == 0)
2541                                         {
2542                                           if (((word >> 13) & 0x1) == 0)
2543                                             {
2544                                               /* 33222222222211111111110000000000
2545                                                  10987654321098765432109876543210
2546                                                  xxxxxxxxxx1100xxxxxxx0xx011100xx
2547                                                  dup.  */
2548                                               return 136;
2549                                             }
2550                                           else
2551                                             {
2552                                               /* 33222222222211111111110000000000
2553                                                  10987654321098765432109876543210
2554                                                  xxxxxxxxxx1101xxxxxxx0xx011100xx
2555                                                  smov.  */
2556                                               return 137;
2557                                             }
2558                                         }
2559                                       else
2560                                         {
2561                                           if (((word >> 13) & 0x1) == 0)
2562                                             {
2563                                               /* 33222222222211111111110000000000
2564                                                  10987654321098765432109876543210
2565                                                  xxxxxxxxxx1110xxxxxxx0xx011100xx
2566                                                  ins.  */
2567                                               return 140;
2568                                             }
2569                                           else
2570                                             {
2571                                               /* 33222222222211111111110000000000
2572                                                  10987654321098765432109876543210
2573                                                  xxxxxxxxxx1111xxxxxxx0xx011100xx
2574                                                  umov.  */
2575                                               return 138;
2576                                             }
2577                                         }
2578                                     }
2579                                 }
2580                               else
2581                                 {
2582                                   /* 33222222222211111111110000000000
2583                                      10987654321098765432109876543210
2584                                      xxxxxxxxxx1xxxxxxxxxx0xx011101xx
2585                                      ins.  */
2586                                   return 142;
2587                                 }
2588                             }
2589                         }
2590                       else
2591                         {
2592                           if (((word >> 30) & 0x1) == 0)
2593                             {
2594                               if (((word >> 16) & 0x1) == 0)
2595                                 {
2596                                   if (((word >> 17) & 0x1) == 0)
2597                                     {
2598                                       /* 33222222222211111111110000000000
2599                                          10987654321098765432109876543210
2600                                          xxxxxxxxxxxxxxxx00xxx0xx01111x0x
2601                                          fcvtzs.  */
2602                                       return 598;
2603                                     }
2604                                   else
2605                                     {
2606                                       /* 33222222222211111111110000000000
2607                                          10987654321098765432109876543210
2608                                          xxxxxxxxxxxxxxxx01xxx0xx01111x0x
2609                                          scvtf.  */
2610                                       return 596;
2611                                     }
2612                                 }
2613                               else
2614                                 {
2615                                   if (((word >> 17) & 0x1) == 0)
2616                                     {
2617                                       /* 33222222222211111111110000000000
2618                                          10987654321098765432109876543210
2619                                          xxxxxxxxxxxxxxxx10xxx0xx01111x0x
2620                                          fcvtzu.  */
2621                                       return 599;
2622                                     }
2623                                   else
2624                                     {
2625                                       /* 33222222222211111111110000000000
2626                                          10987654321098765432109876543210
2627                                          xxxxxxxxxxxxxxxx11xxx0xx01111x0x
2628                                          ucvtf.  */
2629                                       return 597;
2630                                     }
2631                                 }
2632                             }
2633                           else
2634                             {
2635                               if (((word >> 10) & 0x1) == 0)
2636                                 {
2637                                   if (((word >> 12) & 0x1) == 0)
2638                                     {
2639                                       if (((word >> 13) & 0x1) == 0)
2640                                         {
2641                                           if (((word >> 14) & 0x1) == 0)
2642                                             {
2643                                               /* 33222222222211111111110000000000
2644                                                  10987654321098765432109876543210
2645                                                  xxxxxxxxxx0x000xxxxxx0xx01111x1x
2646                                                  sha1c.  */
2647                                               return 540;
2648                                             }
2649                                           else
2650                                             {
2651                                               /* 33222222222211111111110000000000
2652                                                  10987654321098765432109876543210
2653                                                  xxxxxxxxxx0x001xxxxxx0xx01111x1x
2654                                                  sha256h.  */
2655                                               return 544;
2656                                             }
2657                                         }
2658                                       else
2659                                         {
2660                                           if (((word >> 14) & 0x1) == 0)
2661                                             {
2662                                               /* 33222222222211111111110000000000
2663                                                  10987654321098765432109876543210
2664                                                  xxxxxxxxxx0x010xxxxxx0xx01111x1x
2665                                                  sha1m.  */
2666                                               return 542;
2667                                             }
2668                                           else
2669                                             {
2670                                               /* 33222222222211111111110000000000
2671                                                  10987654321098765432109876543210
2672                                                  xxxxxxxxxx0x011xxxxxx0xx01111x1x
2673                                                  sha256su1.  */
2674                                               return 546;
2675                                             }
2676                                         }
2677                                     }
2678                                   else
2679                                     {
2680                                       if (((word >> 13) & 0x1) == 0)
2681                                         {
2682                                           if (((word >> 14) & 0x1) == 0)
2683                                             {
2684                                               /* 33222222222211111111110000000000
2685                                                  10987654321098765432109876543210
2686                                                  xxxxxxxxxx0x100xxxxxx0xx01111x1x
2687                                                  sha1p.  */
2688                                               return 541;
2689                                             }
2690                                           else
2691                                             {
2692                                               /* 33222222222211111111110000000000
2693                                                  10987654321098765432109876543210
2694                                                  xxxxxxxxxx0x101xxxxxx0xx01111x1x
2695                                                  sha256h2.  */
2696                                               return 545;
2697                                             }
2698                                         }
2699                                       else
2700                                         {
2701                                           /* 33222222222211111111110000000000
2702                                              10987654321098765432109876543210
2703                                              xxxxxxxxxx0x11xxxxxxx0xx01111x1x
2704                                              sha1su0.  */
2705                                           return 543;
2706                                         }
2707                                     }
2708                                 }
2709                               else
2710                                 {
2711                                   /* 33222222222211111111110000000000
2712                                      10987654321098765432109876543210
2713                                      xxxxxxxxxx1xxxxxxxxxx0xx01111x1x
2714                                      dup.  */
2715                                   return 430;
2716                                 }
2717                             }
2718                         }
2719                     }
2720                   else
2721                     {
2722                       if (((word >> 10) & 0x1) == 0)
2723                         {
2724                           if (((word >> 11) & 0x1) == 0)
2725                             {
2726                               if (((word >> 12) & 0x1) == 0)
2727                                 {
2728                                   if (((word >> 13) & 0x1) == 0)
2729                                     {
2730                                       if (((word >> 14) & 0x1) == 0)
2731                                         {
2732                                           if (((word >> 15) & 0x1) == 0)
2733                                             {
2734                                               if (((word >> 28) & 0x1) == 0)
2735                                                 {
2736                                                   if (((word >> 29) & 0x1) == 0)
2737                                                     {
2738                                                       if (((word >> 30) & 0x1) == 0)
2739                                                         {
2740                                                           /* 33222222222211111111110000000000
2741                                                              10987654321098765432109876543210
2742                                                              xxxxxxxxxx000000xxxxx1xx0111000x
2743                                                              saddl.  */
2744                                                           return 38;
2745                                                         }
2746                                                       else
2747                                                         {
2748                                                           /* 33222222222211111111110000000000
2749                                                              10987654321098765432109876543210
2750                                                              xxxxxxxxxx000000xxxxx1xx0111001x
2751                                                              saddl2.  */
2752                                                           return 39;
2753                                                         }
2754                                                     }
2755                                                   else
2756                                                     {
2757                                                       if (((word >> 30) & 0x1) == 0)
2758                                                         {
2759                                                           /* 33222222222211111111110000000000
2760                                                              10987654321098765432109876543210
2761                                                              xxxxxxxxxx000000xxxxx1xx0111010x
2762                                                              uaddl.  */
2763                                                           return 70;
2764                                                         }
2765                                                       else
2766                                                         {
2767                                                           /* 33222222222211111111110000000000
2768                                                              10987654321098765432109876543210
2769                                                              xxxxxxxxxx000000xxxxx1xx0111011x
2770                                                              uaddl2.  */
2771                                                           return 71;
2772                                                         }
2773                                                     }
2774                                                 }
2775                                               else
2776                                                 {
2777                                                   if (((word >> 16) & 0x1) == 0)
2778                                                     {
2779                                                       if (((word >> 17) & 0x1) == 0)
2780                                                         {
2781                                                           if (((word >> 18) & 0x1) == 0)
2782                                                             {
2783                                                               if (((word >> 19) & 0x1) == 0)
2784                                                                 {
2785                                                                   if (((word >> 20) & 0x1) == 0)
2786                                                                     {
2787                                                                       /* 33222222222211111111110000000000
2788                                                                          10987654321098765432109876543210
2789                                                                          xxxxxxxxxx000000000001xx01111xxx
2790                                                                          fcvtns.  */
2791                                                                       return 600;
2792                                                                     }
2793                                                                   else
2794                                                                     {
2795                                                                       /* 33222222222211111111110000000000
2796                                                                          10987654321098765432109876543210
2797                                                                          xxxxxxxxxx000000000011xx01111xxx
2798                                                                          fcvtms.  */
2799                                                                       return 610;
2800                                                                     }
2801                                                                 }
2802                                                               else
2803                                                                 {
2804                                                                   if (((word >> 20) & 0x1) == 0)
2805                                                                     {
2806                                                                       /* 33222222222211111111110000000000
2807                                                                          10987654321098765432109876543210
2808                                                                          xxxxxxxxxx000000000101xx01111xxx
2809                                                                          fcvtps.  */
2810                                                                       return 608;
2811                                                                     }
2812                                                                   else
2813                                                                     {
2814                                                                       /* 33222222222211111111110000000000
2815                                                                          10987654321098765432109876543210
2816                                                                          xxxxxxxxxx000000000111xx01111xxx
2817                                                                          fcvtzs.  */
2818                                                                       return 612;
2819                                                                     }
2820                                                                 }
2821                                                             }
2822                                                           else
2823                                                             {
2824                                                               /* 33222222222211111111110000000000
2825                                                                  10987654321098765432109876543210
2826                                                                  xxxxxxxxxx000000001xx1xx01111xxx
2827                                                                  fcvtas.  */
2828                                                               return 604;
2829                                                             }
2830                                                         }
2831                                                       else
2832                                                         {
2833                                                           if (((word >> 18) & 0x1) == 0)
2834                                                             {
2835                                                               /* 33222222222211111111110000000000
2836                                                                  10987654321098765432109876543210
2837                                                                  xxxxxxxxxx000000010xx1xx01111xxx
2838                                                                  scvtf.  */
2839                                                               return 602;
2840                                                             }
2841                                                           else
2842                                                             {
2843                                                               if (((word >> 19) & 0x1) == 0)
2844                                                                 {
2845                                                                   /* 33222222222211111111110000000000
2846                                                                      10987654321098765432109876543210
2847                                                                      xxxxxxxxxx0000000110x1xx01111xxx
2848                                                                      fmov.  */
2849                                                                   return 606;
2850                                                                 }
2851                                                               else
2852                                                                 {
2853                                                                   /* 33222222222211111111110000000000
2854                                                                      10987654321098765432109876543210
2855                                                                      xxxxxxxxxx0000000111x1xx01111xxx
2856                                                                      fmov.  */
2857                                                                   return 614;
2858                                                                 }
2859                                                             }
2860                                                         }
2861                                                     }
2862                                                   else
2863                                                     {
2864                                                       if (((word >> 17) & 0x1) == 0)
2865                                                         {
2866                                                           if (((word >> 18) & 0x1) == 0)
2867                                                             {
2868                                                               if (((word >> 19) & 0x1) == 0)
2869                                                                 {
2870                                                                   if (((word >> 20) & 0x1) == 0)
2871                                                                     {
2872                                                                       /* 33222222222211111111110000000000
2873                                                                          10987654321098765432109876543210
2874                                                                          xxxxxxxxxx000000100001xx01111xxx
2875                                                                          fcvtnu.  */
2876                                                                       return 601;
2877                                                                     }
2878                                                                   else
2879                                                                     {
2880                                                                       /* 33222222222211111111110000000000
2881                                                                          10987654321098765432109876543210
2882                                                                          xxxxxxxxxx000000100011xx01111xxx
2883                                                                          fcvtmu.  */
2884                                                                       return 611;
2885                                                                     }
2886                                                                 }
2887                                                               else
2888                                                                 {
2889                                                                   if (((word >> 20) & 0x1) == 0)
2890                                                                     {
2891                                                                       /* 33222222222211111111110000000000
2892                                                                          10987654321098765432109876543210
2893                                                                          xxxxxxxxxx000000100101xx01111xxx
2894                                                                          fcvtpu.  */
2895                                                                       return 609;
2896                                                                     }
2897                                                                   else
2898                                                                     {
2899                                                                       /* 33222222222211111111110000000000
2900                                                                          10987654321098765432109876543210
2901                                                                          xxxxxxxxxx000000100111xx01111xxx
2902                                                                          fcvtzu.  */
2903                                                                       return 613;
2904                                                                     }
2905                                                                 }
2906                                                             }
2907                                                           else
2908                                                             {
2909                                                               /* 33222222222211111111110000000000
2910                                                                  10987654321098765432109876543210
2911                                                                  xxxxxxxxxx000000101xx1xx01111xxx
2912                                                                  fcvtau.  */
2913                                                               return 605;
2914                                                             }
2915                                                         }
2916                                                       else
2917                                                         {
2918                                                           if (((word >> 18) & 0x1) == 0)
2919                                                             {
2920                                                               /* 33222222222211111111110000000000
2921                                                                  10987654321098765432109876543210
2922                                                                  xxxxxxxxxx000000110xx1xx01111xxx
2923                                                                  ucvtf.  */
2924                                                               return 603;
2925                                                             }
2926                                                           else
2927                                                             {
2928                                                               if (((word >> 19) & 0x1) == 0)
2929                                                                 {
2930                                                                   /* 33222222222211111111110000000000
2931                                                                      10987654321098765432109876543210
2932                                                                      xxxxxxxxxx0000001110x1xx01111xxx
2933                                                                      fmov.  */
2934                                                                   return 607;
2935                                                                 }
2936                                                               else
2937                                                                 {
2938                                                                   /* 33222222222211111111110000000000
2939                                                                      10987654321098765432109876543210
2940                                                                      xxxxxxxxxx0000001111x1xx01111xxx
2941                                                                      fmov.  */
2942                                                                   return 615;
2943                                                                 }
2944                                                             }
2945                                                         }
2946                                                     }
2947                                                 }
2948                                             }
2949                                           else
2950                                             {
2951                                               if (((word >> 29) & 0x1) == 0)
2952                                                 {
2953                                                   if (((word >> 30) & 0x1) == 0)
2954                                                     {
2955                                                       /* 33222222222211111111110000000000
2956                                                          10987654321098765432109876543210
2957                                                          xxxxxxxxxx000001xxxxx1xx0111x00x
2958                                                          smlal.  */
2959                                                       return 54;
2960                                                     }
2961                                                   else
2962                                                     {
2963                                                       /* 33222222222211111111110000000000
2964                                                          10987654321098765432109876543210
2965                                                          xxxxxxxxxx000001xxxxx1xx0111x01x
2966                                                          smlal2.  */
2967                                                       return 55;
2968                                                     }
2969                                                 }
2970                                               else
2971                                                 {
2972                                                   if (((word >> 30) & 0x1) == 0)
2973                                                     {
2974                                                       /* 33222222222211111111110000000000
2975                                                          10987654321098765432109876543210
2976                                                          xxxxxxxxxx000001xxxxx1xx0111x10x
2977                                                          umlal.  */
2978                                                       return 86;
2979                                                     }
2980                                                   else
2981                                                     {
2982                                                       /* 33222222222211111111110000000000
2983                                                          10987654321098765432109876543210
2984                                                          xxxxxxxxxx000001xxxxx1xx0111x11x
2985                                                          umlal2.  */
2986                                                       return 87;
2987                                                     }
2988                                                 }
2989                                             }
2990                                         }
2991                                       else
2992                                         {
2993                                           if (((word >> 28) & 0x1) == 0)
2994                                             {
2995                                               if (((word >> 15) & 0x1) == 0)
2996                                                 {
2997                                                   if (((word >> 29) & 0x1) == 0)
2998                                                     {
2999                                                       if (((word >> 30) & 0x1) == 0)
3000                                                         {
3001                                                           /* 33222222222211111111110000000000
3002                                                              10987654321098765432109876543210
3003                                                              xxxxxxxxxx000010xxxxx1xx0111000x
3004                                                              addhn.  */
3005                                                           return 46;
3006                                                         }
3007                                                       else
3008                                                         {
3009                                                           /* 33222222222211111111110000000000
3010                                                              10987654321098765432109876543210
3011                                                              xxxxxxxxxx000010xxxxx1xx0111001x
3012                                                              addhn2.  */
3013                                                           return 47;
3014                                                         }
3015                                                     }
3016                                                   else
3017                                                     {
3018                                                       if (((word >> 30) & 0x1) == 0)
3019                                                         {
3020                                                           /* 33222222222211111111110000000000
3021                                                              10987654321098765432109876543210
3022                                                              xxxxxxxxxx000010xxxxx1xx0111010x
3023                                                              raddhn.  */
3024                                                           return 78;
3025                                                         }
3026                                                       else
3027                                                         {
3028                                                           /* 33222222222211111111110000000000
3029                                                              10987654321098765432109876543210
3030                                                              xxxxxxxxxx000010xxxxx1xx0111011x
3031                                                              raddhn2.  */
3032                                                           return 79;
3033                                                         }
3034                                                     }
3035                                                 }
3036                                               else
3037                                                 {
3038                                                   if (((word >> 29) & 0x1) == 0)
3039                                                     {
3040                                                       if (((word >> 30) & 0x1) == 0)
3041                                                         {
3042                                                           /* 33222222222211111111110000000000
3043                                                              10987654321098765432109876543210
3044                                                              xxxxxxxxxx000011xxxxx1xx0111000x
3045                                                              smull.  */
3046                                                           return 62;
3047                                                         }
3048                                                       else
3049                                                         {
3050                                                           /* 33222222222211111111110000000000
3051                                                              10987654321098765432109876543210
3052                                                              xxxxxxxxxx000011xxxxx1xx0111001x
3053                                                              smull2.  */
3054                                                           return 63;
3055                                                         }
3056                                                     }
3057                                                   else
3058                                                     {
3059                                                       if (((word >> 30) & 0x1) == 0)
3060                                                         {
3061                                                           /* 33222222222211111111110000000000
3062                                                              10987654321098765432109876543210
3063                                                              xxxxxxxxxx000011xxxxx1xx0111010x
3064                                                              umull.  */
3065                                                           return 90;
3066                                                         }
3067                                                       else
3068                                                         {
3069                                                           /* 33222222222211111111110000000000
3070                                                              10987654321098765432109876543210
3071                                                              xxxxxxxxxx000011xxxxx1xx0111011x
3072                                                              umull2.  */
3073                                                           return 91;
3074                                                         }
3075                                                     }
3076                                                 }
3077                                             }
3078                                           else
3079                                             {
3080                                               if (((word >> 17) & 0x1) == 0)
3081                                                 {
3082                                                   if (((word >> 15) & 0x1) == 0)
3083                                                     {
3084                                                       if (((word >> 16) & 0x1) == 0)
3085                                                         {
3086                                                           if (((word >> 18) & 0x1) == 0)
3087                                                             {
3088                                                               /* 33222222222211111111110000000000
3089                                                                  10987654321098765432109876543210
3090                                                                  xxxxxxxxxx000010000xx1xx01111xxx
3091                                                                  fmov.  */
3092                                                               return 622;
3093                                                             }
3094                                                           else
3095                                                             {
3096                                                               /* 33222222222211111111110000000000
3097                                                                  10987654321098765432109876543210
3098                                                                  xxxxxxxxxx000010001xx1xx01111xxx
3099                                                                  frintn.  */
3100                                                               return 627;
3101                                                             }
3102                                                         }
3103                                                       else
3104                                                         {
3105                                                           if (((word >> 18) & 0x1) == 0)
3106                                                             {
3107                                                               /* 33222222222211111111110000000000
3108                                                                  10987654321098765432109876543210
3109                                                                  xxxxxxxxxx000010100xx1xx01111xxx
3110                                                                  fneg.  */
3111                                                               return 624;
3112                                                             }
3113                                                           else
3114                                                             {
3115                                                               /* 33222222222211111111110000000000
3116                                                                  10987654321098765432109876543210
3117                                                                  xxxxxxxxxx000010101xx1xx01111xxx
3118                                                                  frintm.  */
3119                                                               return 629;
3120                                                             }
3121                                                         }
3122                                                     }
3123                                                   else
3124                                                     {
3125                                                       if (((word >> 16) & 0x1) == 0)
3126                                                         {
3127                                                           if (((word >> 18) & 0x1) == 0)
3128                                                             {
3129                                                               /* 33222222222211111111110000000000
3130                                                                  10987654321098765432109876543210
3131                                                                  xxxxxxxxxx000011000xx1xx01111xxx
3132                                                                  fabs.  */
3133                                                               return 623;
3134                                                             }
3135                                                           else
3136                                                             {
3137                                                               /* 33222222222211111111110000000000
3138                                                                  10987654321098765432109876543210
3139                                                                  xxxxxxxxxx000011001xx1xx01111xxx
3140                                                                  frintp.  */
3141                                                               return 628;
3142                                                             }
3143                                                         }
3144                                                       else
3145                                                         {
3146                                                           if (((word >> 18) & 0x1) == 0)
3147                                                             {
3148                                                               /* 33222222222211111111110000000000
3149                                                                  10987654321098765432109876543210
3150                                                                  xxxxxxxxxx000011100xx1xx01111xxx
3151                                                                  fsqrt.  */
3152                                                               return 625;
3153                                                             }
3154                                                           else
3155                                                             {
3156                                                               /* 33222222222211111111110000000000
3157                                                                  10987654321098765432109876543210
3158                                                                  xxxxxxxxxx000011101xx1xx01111xxx
3159                                                                  frintz.  */
3160                                                               return 630;
3161                                                             }
3162                                                         }
3163                                                     }
3164                                                 }
3165                                               else
3166                                                 {
3167                                                   if (((word >> 18) & 0x1) == 0)
3168                                                     {
3169                                                       /* 33222222222211111111110000000000
3170                                                          10987654321098765432109876543210
3171                                                          xxxxxxxxxx00001xx10xx1xx01111xxx
3172                                                          fcvt.  */
3173                                                       return 626;
3174                                                     }
3175                                                   else
3176                                                     {
3177                                                       if (((word >> 15) & 0x1) == 0)
3178                                                         {
3179                                                           if (((word >> 16) & 0x1) == 0)
3180                                                             {
3181                                                               /* 33222222222211111111110000000000
3182                                                                  10987654321098765432109876543210
3183                                                                  xxxxxxxxxx000010011xx1xx01111xxx
3184                                                                  frinta.  */
3185                                                               return 631;
3186                                                             }
3187                                                           else
3188                                                             {
3189                                                               /* 33222222222211111111110000000000
3190                                                                  10987654321098765432109876543210
3191                                                                  xxxxxxxxxx000010111xx1xx01111xxx
3192                                                                  frintx.  */
3193                                                               return 632;
3194                                                             }
3195                                                         }
3196                                                       else
3197                                                         {
3198                                                           /* 33222222222211111111110000000000
3199                                                              10987654321098765432109876543210
3200                                                              xxxxxxxxxx000011x11xx1xx01111xxx
3201                                                              frinti.  */
3202                                                           return 633;
3203                                                         }
3204                                                     }
3205                                                 }
3206                                             }
3207                                         }
3208                                     }
3209                                   else
3210                                     {
3211                                       if (((word >> 14) & 0x1) == 0)
3212                                         {
3213                                           if (((word >> 15) & 0x1) == 0)
3214                                             {
3215                                               if (((word >> 28) & 0x1) == 0)
3216                                                 {
3217                                                   if (((word >> 29) & 0x1) == 0)
3218                                                     {
3219                                                       if (((word >> 30) & 0x1) == 0)
3220                                                         {
3221                                                           /* 33222222222211111111110000000000
3222                                                              10987654321098765432109876543210
3223                                                              xxxxxxxxxx000100xxxxx1xx0111000x
3224                                                              ssubl.  */
3225                                                           return 42;
3226                                                         }
3227                                                       else
3228                                                         {
3229                                                           /* 33222222222211111111110000000000
3230                                                              10987654321098765432109876543210
3231                                                              xxxxxxxxxx000100xxxxx1xx0111001x
3232                                                              ssubl2.  */
3233                                                           return 43;
3234                                                         }
3235                                                     }
3236                                                   else
3237                                                     {
3238                                                       if (((word >> 30) & 0x1) == 0)
3239                                                         {
3240                                                           /* 33222222222211111111110000000000
3241                                                              10987654321098765432109876543210
3242                                                              xxxxxxxxxx000100xxxxx1xx0111010x
3243                                                              usubl.  */
3244                                                           return 74;
3245                                                         }
3246                                                       else
3247                                                         {
3248                                                           /* 33222222222211111111110000000000
3249                                                              10987654321098765432109876543210
3250                                                              xxxxxxxxxx000100xxxxx1xx0111011x
3251                                                              usubl2.  */
3252                                                           return 75;
3253                                                         }
3254                                                     }
3255                                                 }
3256                                               else
3257                                                 {
3258                                                   if (((word >> 3) & 0x1) == 0)
3259                                                     {
3260                                                       if (((word >> 4) & 0x1) == 0)
3261                                                         {
3262                                                           /* 33222222222211111111110000000000
3263                                                              10987654321098765432109876543210
3264                                                              xxx00xxxxx000100xxxxx1xx01111xxx
3265                                                              fcmp.  */
3266                                                           return 618;
3267                                                         }
3268                                                       else
3269                                                         {
3270                                                           /* 33222222222211111111110000000000
3271                                                              10987654321098765432109876543210
3272                                                              xxx01xxxxx000100xxxxx1xx01111xxx
3273                                                              fcmpe.  */
3274                                                           return 619;
3275                                                         }
3276                                                     }
3277                                                   else
3278                                                     {
3279                                                       if (((word >> 4) & 0x1) == 0)
3280                                                         {
3281                                                           /* 33222222222211111111110000000000
3282                                                              10987654321098765432109876543210
3283                                                              xxx10xxxxx000100xxxxx1xx01111xxx
3284                                                              fcmp.  */
3285                                                           return 620;
3286                                                         }
3287                                                       else
3288                                                         {
3289                                                           /* 33222222222211111111110000000000
3290                                                              10987654321098765432109876543210
3291                                                              xxx11xxxxx000100xxxxx1xx01111xxx
3292                                                              fcmpe.  */
3293                                                           return 621;
3294                                                         }
3295                                                     }
3296                                                 }
3297                                             }
3298                                           else
3299                                             {
3300                                               if (((word >> 29) & 0x1) == 0)
3301                                                 {
3302                                                   if (((word >> 30) & 0x1) == 0)
3303                                                     {
3304                                                       /* 33222222222211111111110000000000
3305                                                          10987654321098765432109876543210
3306                                                          xxxxxxxxxx000101xxxxx1xx0111x00x
3307                                                          smlsl.  */
3308                                                       return 58;
3309                                                     }
3310                                                   else
3311                                                     {
3312                                                       /* 33222222222211111111110000000000
3313                                                          10987654321098765432109876543210
3314                                                          xxxxxxxxxx000101xxxxx1xx0111x01x
3315                                                          smlsl2.  */
3316                                                       return 59;
3317                                                     }
3318                                                 }
3319                                               else
3320                                                 {
3321                                                   if (((word >> 30) & 0x1) == 0)
3322                                                     {
3323                                                       /* 33222222222211111111110000000000
3324                                                          10987654321098765432109876543210
3325                                                          xxxxxxxxxx000101xxxxx1xx0111x10x
3326                                                          umlsl.  */
3327                                                       return 88;
3328                                                     }
3329                                                   else
3330                                                     {
3331                                                       /* 33222222222211111111110000000000
3332                                                          10987654321098765432109876543210
3333                                                          xxxxxxxxxx000101xxxxx1xx0111x11x
3334                                                          umlsl2.  */
3335                                                       return 89;
3336                                                     }
3337                                                 }
3338                                             }
3339                                         }
3340                                       else
3341                                         {
3342                                           if (((word >> 15) & 0x1) == 0)
3343                                             {
3344                                               if (((word >> 29) & 0x1) == 0)
3345                                                 {
3346                                                   if (((word >> 30) & 0x1) == 0)
3347                                                     {
3348                                                       /* 33222222222211111111110000000000
3349                                                          10987654321098765432109876543210
3350                                                          xxxxxxxxxx000110xxxxx1xx0111x00x
3351                                                          subhn.  */
3352                                                       return 50;
3353                                                     }
3354                                                   else
3355                                                     {
3356                                                       /* 33222222222211111111110000000000
3357                                                          10987654321098765432109876543210
3358                                                          xxxxxxxxxx000110xxxxx1xx0111x01x
3359                                                          subhn2.  */
3360                                                       return 51;
3361                                                     }
3362                                                 }
3363                                               else
3364                                                 {
3365                                                   if (((word >> 30) & 0x1) == 0)
3366                                                     {
3367                                                       /* 33222222222211111111110000000000
3368                                                          10987654321098765432109876543210
3369                                                          xxxxxxxxxx000110xxxxx1xx0111x10x
3370                                                          rsubhn.  */
3371                                                       return 82;
3372                                                     }
3373                                                   else
3374                                                     {
3375                                                       /* 33222222222211111111110000000000
3376                                                          10987654321098765432109876543210
3377                                                          xxxxxxxxxx000110xxxxx1xx0111x11x
3378                                                          rsubhn2.  */
3379                                                       return 83;
3380                                                     }
3381                                                 }
3382                                             }
3383                                           else
3384                                             {
3385                                               if (((word >> 22) & 0x1) == 0)
3386                                                 {
3387                                                   if (((word >> 30) & 0x1) == 0)
3388                                                     {
3389                                                       /* 33222222222211111111110000000000
3390                                                          10987654321098765432109876543210
3391                                                          xxxxxxxxxx000111xxxxx10x0111xx0x
3392                                                          pmull.  */
3393                                                       return 66;
3394                                                     }
3395                                                   else
3396                                                     {
3397                                                       /* 33222222222211111111110000000000
3398                                                          10987654321098765432109876543210
3399                                                          xxxxxxxxxx000111xxxxx10x0111xx1x
3400                                                          pmull2.  */
3401                                                       return 68;
3402                                                     }
3403                                                 }
3404                                               else
3405                                                 {
3406                                                   if (((word >> 30) & 0x1) == 0)
3407                                                     {
3408                                                       /* 33222222222211111111110000000000
3409                                                          10987654321098765432109876543210
3410                                                          xxxxxxxxxx000111xxxxx11x0111xx0x
3411                                                          pmull.  */
3412                                                       return 67;
3413                                                     }
3414                                                   else
3415                                                     {
3416                                                       /* 33222222222211111111110000000000
3417                                                          10987654321098765432109876543210
3418                                                          xxxxxxxxxx000111xxxxx11x0111xx1x
3419                                                          pmull2.  */
3420                                                       return 69;
3421                                                     }
3422                                                 }
3423                                             }
3424                                         }
3425                                     }
3426                                 }
3427                               else
3428                                 {
3429                                   if (((word >> 28) & 0x1) == 0)
3430                                     {
3431                                       if (((word >> 13) & 0x1) == 0)
3432                                         {
3433                                           if (((word >> 14) & 0x1) == 0)
3434                                             {
3435                                               if (((word >> 15) & 0x1) == 0)
3436                                                 {
3437                                                   if (((word >> 29) & 0x1) == 0)
3438                                                     {
3439                                                       if (((word >> 30) & 0x1) == 0)
3440                                                         {
3441                                                           /* 33222222222211111111110000000000
3442                                                              10987654321098765432109876543210
3443                                                              xxxxxxxxxx001000xxxxx1xx0111000x
3444                                                              saddw.  */
3445                                                           return 40;
3446                                                         }
3447                                                       else
3448                                                         {
3449                                                           /* 33222222222211111111110000000000
3450                                                              10987654321098765432109876543210
3451                                                              xxxxxxxxxx001000xxxxx1xx0111001x
3452                                                              saddw2.  */
3453                                                           return 41;
3454                                                         }
3455                                                     }
3456                                                   else
3457                                                     {
3458                                                       if (((word >> 30) & 0x1) == 0)
3459                                                         {
3460                                                           /* 33222222222211111111110000000000
3461                                                              10987654321098765432109876543210
3462                                                              xxxxxxxxxx001000xxxxx1xx0111010x
3463                                                              uaddw.  */
3464                                                           return 72;
3465                                                         }
3466                                                       else
3467                                                         {
3468                                                           /* 33222222222211111111110000000000
3469                                                              10987654321098765432109876543210
3470                                                              xxxxxxxxxx001000xxxxx1xx0111011x
3471                                                              uaddw2.  */
3472                                                           return 73;
3473                                                         }
3474                                                     }
3475                                                 }
3476                                               else
3477                                                 {
3478                                                   if (((word >> 30) & 0x1) == 0)
3479                                                     {
3480                                                       /* 33222222222211111111110000000000
3481                                                          10987654321098765432109876543210
3482                                                          xxxxxxxxxx001001xxxxx1xx01110x0x
3483                                                          sqdmlal.  */
3484                                                       return 56;
3485                                                     }
3486                                                   else
3487                                                     {
3488                                                       /* 33222222222211111111110000000000
3489                                                          10987654321098765432109876543210
3490                                                          xxxxxxxxxx001001xxxxx1xx01110x1x
3491                                                          sqdmlal2.  */
3492                                                       return 57;
3493                                                     }
3494                                                 }
3495                                             }
3496                                           else
3497                                             {
3498                                               if (((word >> 15) & 0x1) == 0)
3499                                                 {
3500                                                   if (((word >> 29) & 0x1) == 0)
3501                                                     {
3502                                                       if (((word >> 30) & 0x1) == 0)
3503                                                         {
3504                                                           /* 33222222222211111111110000000000
3505                                                              10987654321098765432109876543210
3506                                                              xxxxxxxxxx001010xxxxx1xx0111000x
3507                                                              sabal.  */
3508                                                           return 48;
3509                                                         }
3510                                                       else
3511                                                         {
3512                                                           /* 33222222222211111111110000000000
3513                                                              10987654321098765432109876543210
3514                                                              xxxxxxxxxx001010xxxxx1xx0111001x
3515                                                              sabal2.  */
3516                                                           return 49;
3517                                                         }
3518                                                     }
3519                                                   else
3520                                                     {
3521                                                       if (((word >> 30) & 0x1) == 0)
3522                                                         {
3523                                                           /* 33222222222211111111110000000000
3524                                                              10987654321098765432109876543210
3525                                                              xxxxxxxxxx001010xxxxx1xx0111010x
3526                                                              uabal.  */
3527                                                           return 80;
3528                                                         }
3529                                                       else
3530                                                         {
3531                                                           /* 33222222222211111111110000000000
3532                                                              10987654321098765432109876543210
3533                                                              xxxxxxxxxx001010xxxxx1xx0111011x
3534                                                              uabal2.  */
3535                                                           return 81;
3536                                                         }
3537                                                     }
3538                                                 }
3539                                               else
3540                                                 {
3541                                                   if (((word >> 30) & 0x1) == 0)
3542                                                     {
3543                                                       /* 33222222222211111111110000000000
3544                                                          10987654321098765432109876543210
3545                                                          xxxxxxxxxx001011xxxxx1xx01110x0x
3546                                                          sqdmull.  */
3547                                                       return 64;
3548                                                     }
3549                                                   else
3550                                                     {
3551                                                       /* 33222222222211111111110000000000
3552                                                          10987654321098765432109876543210
3553                                                          xxxxxxxxxx001011xxxxx1xx01110x1x
3554                                                          sqdmull2.  */
3555                                                       return 65;
3556                                                     }
3557                                                 }
3558                                             }
3559                                         }
3560                                       else
3561                                         {
3562                                           if (((word >> 14) & 0x1) == 0)
3563                                             {
3564                                               if (((word >> 15) & 0x1) == 0)
3565                                                 {
3566                                                   if (((word >> 29) & 0x1) == 0)
3567                                                     {
3568                                                       if (((word >> 30) & 0x1) == 0)
3569                                                         {
3570                                                           /* 33222222222211111111110000000000
3571                                                              10987654321098765432109876543210
3572                                                              xxxxxxxxxx001100xxxxx1xx0111000x
3573                                                              ssubw.  */
3574                                                           return 44;
3575                                                         }
3576                                                       else
3577                                                         {
3578                                                           /* 33222222222211111111110000000000
3579                                                              10987654321098765432109876543210
3580                                                              xxxxxxxxxx001100xxxxx1xx0111001x
3581                                                              ssubw2.  */
3582                                                           return 45;
3583                                                         }
3584                                                     }
3585                                                   else
3586                                                     {
3587                                                       if (((word >> 30) & 0x1) == 0)
3588                                                         {
3589                                                           /* 33222222222211111111110000000000
3590                                                              10987654321098765432109876543210
3591                                                              xxxxxxxxxx001100xxxxx1xx0111010x
3592                                                              usubw.  */
3593                                                           return 76;
3594                                                         }
3595                                                       else
3596                                                         {
3597                                                           /* 33222222222211111111110000000000
3598                                                              10987654321098765432109876543210
3599                                                              xxxxxxxxxx001100xxxxx1xx0111011x
3600                                                              usubw2.  */
3601                                                           return 77;
3602                                                         }
3603                                                     }
3604                                                 }
3605                                               else
3606                                                 {
3607                                                   if (((word >> 30) & 0x1) == 0)
3608                                                     {
3609                                                       /* 33222222222211111111110000000000
3610                                                          10987654321098765432109876543210
3611                                                          xxxxxxxxxx001101xxxxx1xx01110x0x
3612                                                          sqdmlsl.  */
3613                                                       return 60;
3614                                                     }
3615                                                   else
3616                                                     {
3617                                                       /* 33222222222211111111110000000000
3618                                                          10987654321098765432109876543210
3619                                                          xxxxxxxxxx001101xxxxx1xx01110x1x
3620                                                          sqdmlsl2.  */
3621                                                       return 61;
3622                                                     }
3623                                                 }
3624                                             }
3625                                           else
3626                                             {
3627                                               if (((word >> 29) & 0x1) == 0)
3628                                                 {
3629                                                   if (((word >> 30) & 0x1) == 0)
3630                                                     {
3631                                                       /* 33222222222211111111110000000000
3632                                                          10987654321098765432109876543210
3633                                                          xxxxxxxxxx00111xxxxxx1xx0111000x
3634                                                          sabdl.  */
3635                                                       return 52;
3636                                                     }
3637                                                   else
3638                                                     {
3639                                                       /* 33222222222211111111110000000000
3640                                                          10987654321098765432109876543210
3641                                                          xxxxxxxxxx00111xxxxxx1xx0111001x
3642                                                          sabdl2.  */
3643                                                       return 53;
3644                                                     }
3645                                                 }
3646                                               else
3647                                                 {
3648                                                   if (((word >> 30) & 0x1) == 0)
3649                                                     {
3650                                                       /* 33222222222211111111110000000000
3651                                                          10987654321098765432109876543210
3652                                                          xxxxxxxxxx00111xxxxxx1xx0111010x
3653                                                          uabdl.  */
3654                                                       return 84;
3655                                                     }
3656                                                   else
3657                                                     {
3658                                                       /* 33222222222211111111110000000000
3659                                                          10987654321098765432109876543210
3660                                                          xxxxxxxxxx00111xxxxxx1xx0111011x
3661                                                          uabdl2.  */
3662                                                       return 85;
3663                                                     }
3664                                                 }
3665                                             }
3666                                         }
3667                                     }
3668                                   else
3669                                     {
3670                                       if (((word >> 30) & 0x1) == 0)
3671                                         {
3672                                           /* 33222222222211111111110000000000
3673                                              10987654321098765432109876543210
3674                                              xxxxxxxxxx001xxxxxxxx1xx01111x0x
3675                                              fmov.  */
3676                                           return 647;
3677                                         }
3678                                       else
3679                                         {
3680                                           if (((word >> 13) & 0x1) == 0)
3681                                             {
3682                                               if (((word >> 14) & 0x1) == 0)
3683                                                 {
3684                                                   /* 33222222222211111111110000000000
3685                                                      10987654321098765432109876543210
3686                                                      xxxxxxxxxx00100xxxxxx1xx01111x1x
3687                                                      sqdmlal.  */
3688                                                   return 343;
3689                                                 }
3690                                               else
3691                                                 {
3692                                                   /* 33222222222211111111110000000000
3693                                                      10987654321098765432109876543210
3694                                                      xxxxxxxxxx00101xxxxxx1xx01111x1x
3695                                                      sqdmull.  */
3696                                                   return 345;
3697                                                 }
3698                                             }
3699                                           else
3700                                             {
3701                                               /* 33222222222211111111110000000000
3702                                                  10987654321098765432109876543210
3703                                                  xxxxxxxxxx0011xxxxxxx1xx01111x1x
3704                                                  sqdmlsl.  */
3705                                               return 344;
3706                                             }
3707                                         }
3708                                     }
3709                                 }
3710                             }
3711                           else
3712                             {
3713                               if (((word >> 12) & 0x1) == 0)
3714                                 {
3715                                   if (((word >> 13) & 0x1) == 0)
3716                                     {
3717                                       if (((word >> 14) & 0x1) == 0)
3718                                         {
3719                                           if (((word >> 15) & 0x1) == 0)
3720                                             {
3721                                               if (((word >> 28) & 0x1) == 0)
3722                                                 {
3723                                                   if (((word >> 29) & 0x1) == 0)
3724                                                     {
3725                                                       /* 33222222222211111111110000000000
3726                                                          10987654321098765432109876543210
3727                                                          xxxxxxxxxx010000xxxxx1xx011100xx
3728                                                          rev64.  */
3729                                                       return 144;
3730                                                     }
3731                                                   else
3732                                                     {
3733                                                       /* 33222222222211111111110000000000
3734                                                          10987654321098765432109876543210
3735                                                          xxxxxxxxxx010000xxxxx1xx011101xx
3736                                                          rev32.  */
3737                                                       return 180;
3738                                                     }
3739                                                 }
3740                                               else
3741                                                 {
3742                                                   if (((word >> 30) & 0x1) == 0)
3743                                                     {
3744                                                       /* 33222222222211111111110000000000
3745                                                          10987654321098765432109876543210
3746                                                          xxxxxxxxxx010000xxxxx1xx01111x0x
3747                                                          fmul.  */
3748                                                       return 634;
3749                                                     }
3750                                                   else
3751                                                     {
3752                                                       /* 33222222222211111111110000000000
3753                                                          10987654321098765432109876543210
3754                                                          xxxxxxxxxx010000xxxxx1xx01111x1x
3755                                                          sha1h.  */
3756                                                       return 537;
3757                                                     }
3758                                                 }
3759                                             }
3760                                           else
3761                                             {
3762                                               if (((word >> 28) & 0x1) == 0)
3763                                                 {
3764                                                   if (((word >> 16) & 0x1) == 0)
3765                                                     {
3766                                                       if (((word >> 29) & 0x1) == 0)
3767                                                         {
3768                                                           /* 33222222222211111111110000000000
3769                                                              10987654321098765432109876543210
3770                                                              xxxxxxxxxx0100010xxxx1xx011100xx
3771                                                              cmgt.  */
3772                                                           return 152;
3773                                                         }
3774                                                       else
3775                                                         {
3776                                                           /* 33222222222211111111110000000000
3777                                                              10987654321098765432109876543210
3778                                                              xxxxxxxxxx0100010xxxx1xx011101xx
3779                                                              cmge.  */
3780                                                           return 186;
3781                                                         }
3782                                                     }
3783                                                   else
3784                                                     {
3785                                                       if (((word >> 23) & 0x1) == 0)
3786                                                         {
3787                                                           if (((word >> 29) & 0x1) == 0)
3788                                                             {
3789                                                               /* 33222222222211111111110000000000
3790                                                                  10987654321098765432109876543210
3791                                                                  xxxxxxxxxx0100011xxxx1x0011100xx
3792                                                                  frintn.  */
3793                                                               return 164;
3794                                                             }
3795                                                           else
3796                                                             {
3797                                                               /* 33222222222211111111110000000000
3798                                                                  10987654321098765432109876543210
3799                                                                  xxxxxxxxxx0100011xxxx1x0011101xx
3800                                                                  frinta.  */
3801                                                               return 197;
3802                                                             }
3803                                                         }
3804                                                       else
3805                                                         {
3806                                                           /* 33222222222211111111110000000000
3807                                                              10987654321098765432109876543210
3808                                                              xxxxxxxxxx0100011xxxx1x101110xxx
3809                                                              frintp.  */
3810                                                           return 174;
3811                                                         }
3812                                                     }
3813                                                 }
3814                                               else
3815                                                 {
3816                                                   if (((word >> 29) & 0x1) == 0)
3817                                                     {
3818                                                       if (((word >> 30) & 0x1) == 0)
3819                                                         {
3820                                                           /* 33222222222211111111110000000000
3821                                                              10987654321098765432109876543210
3822                                                              xxxxxxxxxx010001xxxxx1xx0111100x
3823                                                              fnmul.  */
3824                                                           return 642;
3825                                                         }
3826                                                       else
3827                                                         {
3828                                                           /* 33222222222211111111110000000000
3829                                                              10987654321098765432109876543210
3830                                                              xxxxxxxxxx010001xxxxx1xx0111101x
3831                                                              cmgt.  */
3832                                                           return 397;
3833                                                         }
3834                                                     }
3835                                                   else
3836                                                     {
3837                                                       /* 33222222222211111111110000000000
3838                                                          10987654321098765432109876543210
3839                                                          xxxxxxxxxx010001xxxxx1xx011111xx
3840                                                          cmge.  */
3841                                                       return 415;
3842                                                     }
3843                                                 }
3844                                             }
3845                                         }
3846                                       else
3847                                         {
3848                                           if (((word >> 15) & 0x1) == 0)
3849                                             {
3850                                               if (((word >> 28) & 0x1) == 0)
3851                                                 {
3852                                                   if (((word >> 16) & 0x1) == 0)
3853                                                     {
3854                                                       if (((word >> 19) & 0x1) == 0)
3855                                                         {
3856                                                           if (((word >> 29) & 0x1) == 0)
3857                                                             {
3858                                                               /* 33222222222211111111110000000000
3859                                                                  10987654321098765432109876543210
3860                                                                  xxxxxxxxxx0100100xx0x1xx011100xx
3861                                                                  cls.  */
3862                                                               return 148;
3863                                                             }
3864                                                           else
3865                                                             {
3866                                                               /* 33222222222211111111110000000000
3867                                                                  10987654321098765432109876543210
3868                                                                  xxxxxxxxxx0100100xx0x1xx011101xx
3869                                                                  clz.  */
3870                                                               return 183;
3871                                                             }
3872                                                         }
3873                                                       else
3874                                                         {
3875                                                           /* 33222222222211111111110000000000
3876                                                              10987654321098765432109876543210
3877                                                              xxxxxxxxxx0100100xx1x1xx01110xxx
3878                                                              aese.  */
3879                                                           return 533;
3880                                                         }
3881                                                     }
3882                                                   else
3883                                                     {
3884                                                       if (((word >> 29) & 0x1) == 0)
3885                                                         {
3886                                                           if (((word >> 30) & 0x1) == 0)
3887                                                             {
3888                                                               /* 33222222222211111111110000000000
3889                                                                  10987654321098765432109876543210
3890                                                                  xxxxxxxxxx0100101xxxx1xx0111000x
3891                                                                  sqxtn.  */
3892                                                               return 158;
3893                                                             }
3894                                                           else
3895                                                             {
3896                                                               /* 33222222222211111111110000000000
3897                                                                  10987654321098765432109876543210
3898                                                                  xxxxxxxxxx0100101xxxx1xx0111001x
3899                                                                  sqxtn2.  */
3900                                                               return 159;
3901                                                             }
3902                                                         }
3903                                                       else
3904                                                         {
3905                                                           if (((word >> 30) & 0x1) == 0)
3906                                                             {
3907                                                               /* 33222222222211111111110000000000
3908                                                                  10987654321098765432109876543210
3909                                                                  xxxxxxxxxx0100101xxxx1xx0111010x
3910                                                                  uqxtn.  */
3911                                                               return 193;
3912                                                             }
3913                                                           else
3914                                                             {
3915                                                               /* 33222222222211111111110000000000
3916                                                                  10987654321098765432109876543210
3917                                                                  xxxxxxxxxx0100101xxxx1xx0111011x
3918                                                                  uqxtn2.  */
3919                                                               return 194;
3920                                                             }
3921                                                         }
3922                                                     }
3923                                                 }
3924                                               else
3925                                                 {
3926                                                   if (((word >> 29) & 0x1) == 0)
3927                                                     {
3928                                                       if (((word >> 30) & 0x1) == 0)
3929                                                         {
3930                                                           /* 33222222222211111111110000000000
3931                                                              10987654321098765432109876543210
3932                                                              xxxxxxxxxx010010xxxxx1xx0111100x
3933                                                              fmax.  */
3934                                                           return 638;
3935                                                         }
3936                                                       else
3937                                                         {
3938                                                           /* 33222222222211111111110000000000
3939                                                              10987654321098765432109876543210
3940                                                              xxxxxxxxxx010010xxxxx1xx0111101x
3941                                                              sqxtn.  */
3942                                                           return 401;
3943                                                         }
3944                                                     }
3945                                                   else
3946                                                     {
3947                                                       /* 33222222222211111111110000000000
3948                                                          10987654321098765432109876543210
3949                                                          xxxxxxxxxx010010xxxxx1xx011111xx
3950                                                          uqxtn.  */
3951                                                       return 419;
3952                                                     }
3953                                                 }
3954                                             }
3955                                           else
3956                                             {
3957                                               if (((word >> 16) & 0x1) == 0)
3958                                                 {
3959                                                   if (((word >> 20) & 0x1) == 0)
3960                                                     {
3961                                                       if (((word >> 28) & 0x1) == 0)
3962                                                         {
3963                                                           if (((word >> 29) & 0x1) == 0)
3964                                                             {
3965                                                               /* 33222222222211111111110000000000
3966                                                                  10987654321098765432109876543210
3967                                                                  xxxxxxxxxx0100110xxx01xx011100xx
3968                                                                  fcmgt.  */
3969                                                               return 170;
3970                                                             }
3971                                                           else
3972                                                             {
3973                                                               /* 33222222222211111111110000000000
3974                                                                  10987654321098765432109876543210
3975                                                                  xxxxxxxxxx0100110xxx01xx011101xx
3976                                                                  fcmge.  */
3977                                                               return 206;
3978                                                             }
3979                                                         }
3980                                                       else
3981                                                         {
3982                                                           if (((word >> 29) & 0x1) == 0)
3983                                                             {
3984                                                               /* 33222222222211111111110000000000
3985                                                                  10987654321098765432109876543210
3986                                                                  xxxxxxxxxx0100110xxx01xx011110xx
3987                                                                  fcmgt.  */
3988                                                               return 406;
3989                                                             }
3990                                                           else
3991                                                             {
3992                                                               /* 33222222222211111111110000000000
3993                                                                  10987654321098765432109876543210
3994                                                                  xxxxxxxxxx0100110xxx01xx011111xx
3995                                                                  fcmge.  */
3996                                                               return 425;
3997                                                             }
3998                                                         }
3999                                                     }
4000                                                   else
4001                                                     {
4002                                                       if (((word >> 23) & 0x1) == 0)
4003                                                         {
4004                                                           if (((word >> 28) & 0x1) == 0)
4005                                                             {
4006                                                               /* 33222222222211111111110000000000
4007                                                                  10987654321098765432109876543210
4008                                                                  xxxxxxxxxx0100110xxx11x001110xxx
4009                                                                  fmaxnmv.  */
4010                                                               return 34;
4011                                                             }
4012                                                           else
4013                                                             {
4014                                                               /* 33222222222211111111110000000000
4015                                                                  10987654321098765432109876543210
4016                                                                  xxxxxxxxxx0100110xxx11x001111xxx
4017                                                                  fmaxnmp.  */
4018                                                               return 433;
4019                                                             }
4020                                                         }
4021                                                       else
4022                                                         {
4023                                                           if (((word >> 28) & 0x1) == 0)
4024                                                             {
4025                                                               /* 33222222222211111111110000000000
4026                                                                  10987654321098765432109876543210
4027                                                                  xxxxxxxxxx0100110xxx11x101110xxx
4028                                                                  fminnmv.  */
4029                                                               return 36;
4030                                                             }
4031                                                           else
4032                                                             {
4033                                                               /* 33222222222211111111110000000000
4034                                                                  10987654321098765432109876543210
4035                                                                  xxxxxxxxxx0100110xxx11x101111xxx
4036                                                                  fminnmp.  */
4037                                                               return 436;
4038                                                             }
4039                                                         }
4040                                                     }
4041                                                 }
4042                                               else
4043                                                 {
4044                                                   if (((word >> 23) & 0x1) == 0)
4045                                                     {
4046                                                       if (((word >> 28) & 0x1) == 0)
4047                                                         {
4048                                                           if (((word >> 29) & 0x1) == 0)
4049                                                             {
4050                                                               /* 33222222222211111111110000000000
4051                                                                  10987654321098765432109876543210
4052                                                                  xxxxxxxxxx0100111xxxx1x0011100xx
4053                                                                  fcvtas.  */
4054                                                               return 168;
4055                                                             }
4056                                                           else
4057                                                             {
4058                                                               /* 33222222222211111111110000000000
4059                                                                  10987654321098765432109876543210
4060                                                                  xxxxxxxxxx0100111xxxx1x0011101xx
4061                                                                  fcvtau.  */
4062                                                               return 201;
4063                                                             }
4064                                                         }
4065                                                       else
4066                                                         {
4067                                                           if (((word >> 29) & 0x1) == 0)
4068                                                             {
4069                                                               /* 33222222222211111111110000000000
4070                                                                  10987654321098765432109876543210
4071                                                                  xxxxxxxxxx0100111xxxx1x0011110xx
4072                                                                  fcvtas.  */
4073                                                               return 404;
4074                                                             }
4075                                                           else
4076                                                             {
4077                                                               /* 33222222222211111111110000000000
4078                                                                  10987654321098765432109876543210
4079                                                                  xxxxxxxxxx0100111xxxx1x0011111xx
4080                                                                  fcvtau.  */
4081                                                               return 423;
4082                                                             }
4083                                                         }
4084                                                     }
4085                                                   else
4086                                                     {
4087                                                       if (((word >> 29) & 0x1) == 0)
4088                                                         {
4089                                                           /* 33222222222211111111110000000000
4090                                                              10987654321098765432109876543210
4091                                                              xxxxxxxxxx0100111xxxx1x10111x0xx
4092                                                              urecpe.  */
4093                                                           return 178;
4094                                                         }
4095                                                       else
4096                                                         {
4097                                                           /* 33222222222211111111110000000000
4098                                                              10987654321098765432109876543210
4099                                                              xxxxxxxxxx0100111xxxx1x10111x1xx
4100                                                              ursqrte.  */
4101                                                           return 212;
4102                                                         }
4103                                                     }
4104                                                 }
4105                                             }
4106                                         }
4107                                     }
4108                                   else
4109                                     {
4110                                       if (((word >> 14) & 0x1) == 0)
4111                                         {
4112                                           if (((word >> 15) & 0x1) == 0)
4113                                             {
4114                                               if (((word >> 28) & 0x1) == 0)
4115                                                 {
4116                                                   if (((word >> 16) & 0x1) == 0)
4117                                                     {
4118                                                       if (((word >> 29) & 0x1) == 0)
4119                                                         {
4120                                                           /* 33222222222211111111110000000000
4121                                                              10987654321098765432109876543210
4122                                                              xxxxxxxxxx0101000xxxx1xx011100xx
4123                                                              saddlp.  */
4124                                                           return 146;
4125                                                         }
4126                                                       else
4127                                                         {
4128                                                           /* 33222222222211111111110000000000
4129                                                              10987654321098765432109876543210
4130                                                              xxxxxxxxxx0101000xxxx1xx011101xx
4131                                                              uaddlp.  */
4132                                                           return 181;
4133                                                         }
4134                                                     }
4135                                                   else
4136                                                     {
4137                                                       if (((word >> 29) & 0x1) == 0)
4138                                                         {
4139                                                           if (((word >> 30) & 0x1) == 0)
4140                                                             {
4141                                                               /* 33222222222211111111110000000000
4142                                                                  10987654321098765432109876543210
4143                                                                  xxxxxxxxxx0101001xxxx1xx0111000x
4144                                                                  xtn.  */
4145                                                               return 156;
4146                                                             }
4147                                                           else
4148                                                             {
4149                                                               /* 33222222222211111111110000000000
4150                                                                  10987654321098765432109876543210
4151                                                                  xxxxxxxxxx0101001xxxx1xx0111001x
4152                                                                  xtn2.  */
4153                                                               return 157;
4154                                                             }
4155                                                         }
4156                                                       else
4157                                                         {
4158                                                           if (((word >> 30) & 0x1) == 0)
4159                                                             {
4160                                                               /* 33222222222211111111110000000000
4161                                                                  10987654321098765432109876543210
4162                                                                  xxxxxxxxxx0101001xxxx1xx0111010x
4163                                                                  sqxtun.  */
4164                                                               return 189;
4165                                                             }
4166                                                           else
4167                                                             {
4168                                                               /* 33222222222211111111110000000000
4169                                                                  10987654321098765432109876543210
4170                                                                  xxxxxxxxxx0101001xxxx1xx0111011x
4171                                                                  sqxtun2.  */
4172                                                               return 190;
4173                                                             }
4174                                                         }
4175                                                     }
4176                                                 }
4177                                               else
4178                                                 {
4179                                                   if (((word >> 29) & 0x1) == 0)
4180                                                     {
4181                                                       if (((word >> 30) & 0x1) == 0)
4182                                                         {
4183                                                           /* 33222222222211111111110000000000
4184                                                              10987654321098765432109876543210
4185                                                              xxxxxxxxxx010100xxxxx1xx0111100x
4186                                                              fadd.  */
4187                                                           return 636;
4188                                                         }
4189                                                       else
4190                                                         {
4191                                                           /* 33222222222211111111110000000000
4192                                                              10987654321098765432109876543210
4193                                                              xxxxxxxxxx010100xxxxx1xx0111101x
4194                                                              sha256su0.  */
4195                                                           return 539;
4196                                                         }
4197                                                     }
4198                                                   else
4199                                                     {
4200                                                       /* 33222222222211111111110000000000
4201                                                          10987654321098765432109876543210
4202                                                          xxxxxxxxxx010100xxxxx1xx011111xx
4203                                                          sqxtun.  */
4204                                                       return 418;
4205                                                     }
4206                                                 }
4207                                             }
4208                                           else
4209                                             {
4210                                               if (((word >> 16) & 0x1) == 0)
4211                                                 {
4212                                                   if (((word >> 20) & 0x1) == 0)
4213                                                     {
4214                                                       if (((word >> 28) & 0x1) == 0)
4215                                                         {
4216                                                           /* 33222222222211111111110000000000
4217                                                              10987654321098765432109876543210
4218                                                              xxxxxxxxxx0101010xxx01xx01110xxx
4219                                                              cmlt.  */
4220                                                           return 154;
4221                                                         }
4222                                                       else
4223                                                         {
4224                                                           /* 33222222222211111111110000000000
4225                                                              10987654321098765432109876543210
4226                                                              xxxxxxxxxx0101010xxx01xx01111xxx
4227                                                              cmlt.  */
4228                                                           return 399;
4229                                                         }
4230                                                     }
4231                                                   else
4232                                                     {
4233                                                       if (((word >> 29) & 0x1) == 0)
4234                                                         {
4235                                                           /* 33222222222211111111110000000000
4236                                                              10987654321098765432109876543210
4237                                                              xxxxxxxxxx0101010xxx11xx0111x0xx
4238                                                              smaxv.  */
4239                                                           return 28;
4240                                                         }
4241                                                       else
4242                                                         {
4243                                                           /* 33222222222211111111110000000000
4244                                                              10987654321098765432109876543210
4245                                                              xxxxxxxxxx0101010xxx11xx0111x1xx
4246                                                              umaxv.  */
4247                                                           return 32;
4248                                                         }
4249                                                     }
4250                                                 }
4251                                               else
4252                                                 {
4253                                                   if (((word >> 20) & 0x1) == 0)
4254                                                     {
4255                                                       if (((word >> 23) & 0x1) == 0)
4256                                                         {
4257                                                           if (((word >> 28) & 0x1) == 0)
4258                                                             {
4259                                                               if (((word >> 29) & 0x1) == 0)
4260                                                                 {
4261                                                                   /* 33222222222211111111110000000000
4262                                                                      10987654321098765432109876543210
4263                                                                      xxxxxxxxxx0101011xxx01x0011100xx
4264                                                                      fcvtns.  */
4265                                                                   return 166;
4266                                                                 }
4267                                                               else
4268                                                                 {
4269                                                                   /* 33222222222211111111110000000000
4270                                                                      10987654321098765432109876543210
4271                                                                      xxxxxxxxxx0101011xxx01x0011101xx
4272                                                                      fcvtnu.  */
4273                                                                   return 199;
4274                                                                 }
4275                                                             }
4276                                                           else
4277                                                             {
4278                                                               if (((word >> 29) & 0x1) == 0)
4279                                                                 {
4280                                                                   /* 33222222222211111111110000000000
4281                                                                      10987654321098765432109876543210
4282                                                                      xxxxxxxxxx0101011xxx01x0011110xx
4283                                                                      fcvtns.  */
4284                                                                   return 402;
4285                                                                 }
4286                                                               else
4287                                                                 {
4288                                                                   /* 33222222222211111111110000000000
4289                                                                      10987654321098765432109876543210
4290                                                                      xxxxxxxxxx0101011xxx01x0011111xx
4291                                                                      fcvtnu.  */
4292                                                                   return 421;
4293                                                                 }
4294                                                             }
4295                                                         }
4296                                                       else
4297                                                         {
4298                                                           if (((word >> 28) & 0x1) == 0)
4299                                                             {
4300                                                               if (((word >> 29) & 0x1) == 0)
4301                                                                 {
4302                                                                   /* 33222222222211111111110000000000
4303                                                                      10987654321098765432109876543210
4304                                                                      xxxxxxxxxx0101011xxx01x1011100xx
4305                                                                      fcvtps.  */
4306                                                                   return 176;
4307                                                                 }
4308                                                               else
4309                                                                 {
4310                                                                   /* 33222222222211111111110000000000
4311                                                                      10987654321098765432109876543210
4312                                                                      xxxxxxxxxx0101011xxx01x1011101xx
4313                                                                      fcvtpu.  */
4314                                                                   return 210;
4315                                                                 }
4316                                                             }
4317                                                           else
4318                                                             {
4319                                                               if (((word >> 29) & 0x1) == 0)
4320                                                                 {
4321                                                                   /* 33222222222211111111110000000000
4322                                                                      10987654321098765432109876543210
4323                                                                      xxxxxxxxxx0101011xxx01x1011110xx
4324                                                                      fcvtps.  */
4325                                                                   return 409;
4326                                                                 }
4327                                                               else
4328                                                                 {
4329                                                                   /* 33222222222211111111110000000000
4330                                                                      10987654321098765432109876543210
4331                                                                      xxxxxxxxxx0101011xxx01x1011111xx
4332                                                                      fcvtpu.  */
4333                                                                   return 427;
4334                                                                 }
4335                                                             }
4336                                                         }
4337                                                     }
4338                                                   else
4339                                                     {
4340                                                       if (((word >> 29) & 0x1) == 0)
4341                                                         {
4342                                                           /* 33222222222211111111110000000000
4343                                                              10987654321098765432109876543210
4344                                                              xxxxxxxxxx0101011xxx11xx0111x0xx
4345                                                              sminv.  */
4346                                                           return 29;
4347                                                         }
4348                                                       else
4349                                                         {
4350                                                           /* 33222222222211111111110000000000
4351                                                              10987654321098765432109876543210
4352                                                              xxxxxxxxxx0101011xxx11xx0111x1xx
4353                                                              uminv.  */
4354                                                           return 33;
4355                                                         }
4356                                                     }
4357                                                 }
4358                                             }
4359                                         }
4360                                       else
4361                                         {
4362                                           if (((word >> 15) & 0x1) == 0)
4363                                             {
4364                                               if (((word >> 28) & 0x1) == 0)
4365                                                 {
4366                                                   if (((word >> 16) & 0x1) == 0)
4367                                                     {
4368                                                       if (((word >> 19) & 0x1) == 0)
4369                                                         {
4370                                                           if (((word >> 29) & 0x1) == 0)
4371                                                             {
4372                                                               /* 33222222222211111111110000000000
4373                                                                  10987654321098765432109876543210
4374                                                                  xxxxxxxxxx0101100xx0x1xx011100xx
4375                                                                  sadalp.  */
4376                                                               return 150;
4377                                                             }
4378                                                           else
4379                                                             {
4380                                                               /* 33222222222211111111110000000000
4381                                                                  10987654321098765432109876543210
4382                                                                  xxxxxxxxxx0101100xx0x1xx011101xx
4383                                                                  uadalp.  */
4384                                                               return 184;
4385                                                             }
4386                                                         }
4387                                                       else
4388                                                         {
4389                                                           /* 33222222222211111111110000000000
4390                                                              10987654321098765432109876543210
4391                                                              xxxxxxxxxx0101100xx1x1xx01110xxx
4392                                                              aesmc.  */
4393                                                           return 535;
4394                                                         }
4395                                                     }
4396                                                   else
4397                                                     {
4398                                                       if (((word >> 29) & 0x1) == 0)
4399                                                         {
4400                                                           if (((word >> 30) & 0x1) == 0)
4401                                                             {
4402                                                               /* 33222222222211111111110000000000
4403                                                                  10987654321098765432109876543210
4404                                                                  xxxxxxxxxx0101101xxxx1xx0111000x
4405                                                                  fcvtn.  */
4406                                                               return 160;
4407                                                             }
4408                                                           else
4409                                                             {
4410                                                               /* 33222222222211111111110000000000
4411                                                                  10987654321098765432109876543210
4412                                                                  xxxxxxxxxx0101101xxxx1xx0111001x
4413                                                                  fcvtn2.  */
4414                                                               return 161;
4415                                                             }
4416                                                         }
4417                                                       else
4418                                                         {
4419                                                           if (((word >> 30) & 0x1) == 0)
4420                                                             {
4421                                                               /* 33222222222211111111110000000000
4422                                                                  10987654321098765432109876543210
4423                                                                  xxxxxxxxxx0101101xxxx1xx0111010x
4424                                                                  fcvtxn.  */
4425                                                               return 195;
4426                                                             }
4427                                                           else
4428                                                             {
4429                                                               /* 33222222222211111111110000000000
4430                                                                  10987654321098765432109876543210
4431                                                                  xxxxxxxxxx0101101xxxx1xx0111011x
4432                                                                  fcvtxn2.  */
4433                                                               return 196;
4434                                                             }
4435                                                         }
4436                                                     }
4437                                                 }
4438                                               else
4439                                                 {
4440                                                   if (((word >> 29) & 0x1) == 0)
4441                                                     {
4442                                                       /* 33222222222211111111110000000000
4443                                                          10987654321098765432109876543210
4444                                                          xxxxxxxxxx010110xxxxx1xx011110xx
4445                                                          fmaxnm.  */
4446                                                       return 640;
4447                                                     }
4448                                                   else
4449                                                     {
4450                                                       /* 33222222222211111111110000000000
4451                                                          10987654321098765432109876543210
4452                                                          xxxxxxxxxx010110xxxxx1xx011111xx
4453                                                          fcvtxn.  */
4454                                                       return 420;
4455                                                     }
4456                                                 }
4457                                             }
4458                                           else
4459                                             {
4460                                               if (((word >> 28) & 0x1) == 0)
4461                                                 {
4462                                                   /* 33222222222211111111110000000000
4463                                                      10987654321098765432109876543210
4464                                                      xxxxxxxxxx010111xxxxx1xx01110xxx
4465                                                      fcmlt.  */
4466                                                   return 172;
4467                                                 }
4468                                               else
4469                                                 {
4470                                                   /* 33222222222211111111110000000000
4471                                                      10987654321098765432109876543210
4472                                                      xxxxxxxxxx010111xxxxx1xx01111xxx
4473                                                      fcmlt.  */
4474                                                   return 408;
4475                                                 }
4476                                             }
4477                                         }
4478                                     }
4479                                 }
4480                               else
4481                                 {
4482                                   if (((word >> 13) & 0x1) == 0)
4483                                     {
4484                                       if (((word >> 14) & 0x1) == 0)
4485                                         {
4486                                           if (((word >> 15) & 0x1) == 0)
4487                                             {
4488                                               if (((word >> 28) & 0x1) == 0)
4489                                                 {
4490                                                   /* 33222222222211111111110000000000
4491                                                      10987654321098765432109876543210
4492                                                      xxxxxxxxxx011000xxxxx1xx01110xxx
4493                                                      rev16.  */
4494                                                   return 145;
4495                                                 }
4496                                               else
4497                                                 {
4498                                                   if (((word >> 30) & 0x1) == 0)
4499                                                     {
4500                                                       /* 33222222222211111111110000000000
4501                                                          10987654321098765432109876543210
4502                                                          xxxxxxxxxx011000xxxxx1xx01111x0x
4503                                                          fdiv.  */
4504                                                       return 635;
4505                                                     }
4506                                                   else
4507                                                     {
4508                                                       /* 33222222222211111111110000000000
4509                                                          10987654321098765432109876543210
4510                                                          xxxxxxxxxx011000xxxxx1xx01111x1x
4511                                                          sha1su1.  */
4512                                                       return 538;
4513                                                     }
4514                                                 }
4515                                             }
4516                                           else
4517                                             {
4518                                               if (((word >> 16) & 0x1) == 0)
4519                                                 {
4520                                                   if (((word >> 28) & 0x1) == 0)
4521                                                     {
4522                                                       if (((word >> 29) & 0x1) == 0)
4523                                                         {
4524                                                           /* 33222222222211111111110000000000
4525                                                              10987654321098765432109876543210
4526                                                              xxxxxxxxxx0110010xxxx1xx011100xx
4527                                                              cmeq.  */
4528                                                           return 153;
4529                                                         }
4530                                                       else
4531                                                         {
4532                                                           /* 33222222222211111111110000000000
4533                                                              10987654321098765432109876543210
4534                                                              xxxxxxxxxx0110010xxxx1xx011101xx
4535                                                              cmle.  */
4536                                                           return 187;
4537                                                         }
4538                                                     }
4539                                                   else
4540                                                     {
4541                                                       if (((word >> 29) & 0x1) == 0)
4542                                                         {
4543                                                           /* 33222222222211111111110000000000
4544                                                              10987654321098765432109876543210
4545                                                              xxxxxxxxxx0110010xxxx1xx011110xx
4546                                                              cmeq.  */
4547                                                           return 398;
4548                                                         }
4549                                                       else
4550                                                         {
4551                                                           /* 33222222222211111111110000000000
4552                                                              10987654321098765432109876543210
4553                                                              xxxxxxxxxx0110010xxxx1xx011111xx
4554                                                              cmle.  */
4555                                                           return 416;
4556                                                         }
4557                                                     }
4558                                                 }
4559                                               else
4560                                                 {
4561                                                   if (((word >> 23) & 0x1) == 0)
4562                                                     {
4563                                                       if (((word >> 29) & 0x1) == 0)
4564                                                         {
4565                                                           /* 33222222222211111111110000000000
4566                                                              10987654321098765432109876543210
4567                                                              xxxxxxxxxx0110011xxxx1x00111x0xx
4568                                                              frintm.  */
4569                                                           return 165;
4570                                                         }
4571                                                       else
4572                                                         {
4573                                                           /* 33222222222211111111110000000000
4574                                                              10987654321098765432109876543210
4575                                                              xxxxxxxxxx0110011xxxx1x00111x1xx
4576                                                              frintx.  */
4577                                                           return 198;
4578                                                         }
4579                                                     }
4580                                                   else
4581                                                     {
4582                                                       if (((word >> 29) & 0x1) == 0)
4583                                                         {
4584                                                           /* 33222222222211111111110000000000
4585                                                              10987654321098765432109876543210
4586                                                              xxxxxxxxxx0110011xxxx1x10111x0xx
4587                                                              frintz.  */
4588                                                           return 175;
4589                                                         }
4590                                                       else
4591                                                         {
4592                                                           /* 33222222222211111111110000000000
4593                                                              10987654321098765432109876543210
4594                                                              xxxxxxxxxx0110011xxxx1x10111x1xx
4595                                                              frinti.  */
4596                                                           return 209;
4597                                                         }
4598                                                     }
4599                                                 }
4600                                             }
4601                                         }
4602                                       else
4603                                         {
4604                                           if (((word >> 15) & 0x1) == 0)
4605                                             {
4606                                               if (((word >> 28) & 0x1) == 0)
4607                                                 {
4608                                                   if (((word >> 19) & 0x1) == 0)
4609                                                     {
4610                                                       if (((word >> 29) & 0x1) == 0)
4611                                                         {
4612                                                           /* 33222222222211111111110000000000
4613                                                              10987654321098765432109876543210
4614                                                              xxxxxxxxxx011010xxx0x1xx011100xx
4615                                                              cnt.  */
4616                                                           return 149;
4617                                                         }
4618                                                       else
4619                                                         {
4620                                                           if (((word >> 22) & 0x1) == 0)
4621                                                             {
4622                                                               /* 33222222222211111111110000000000
4623                                                                  10987654321098765432109876543210
4624                                                                  xxxxxxxxxx011010xxx0x10x011101xx
4625                                                                  not.  */
4626                                                               return 203;
4627                                                             }
4628                                                           else
4629                                                             {
4630                                                               /* 33222222222211111111110000000000
4631                                                                  10987654321098765432109876543210
4632                                                                  xxxxxxxxxx011010xxx0x11x011101xx
4633                                                                  rbit.  */
4634                                                               return 205;
4635                                                             }
4636                                                         }
4637                                                     }
4638                                                   else
4639                                                     {
4640                                                       /* 33222222222211111111110000000000
4641                                                          10987654321098765432109876543210
4642                                                          xxxxxxxxxx011010xxx1x1xx01110xxx
4643                                                          aesd.  */
4644                                                       return 534;
4645                                                     }
4646                                                 }
4647                                               else
4648                                                 {
4649                                                   /* 33222222222211111111110000000000
4650                                                      10987654321098765432109876543210
4651                                                      xxxxxxxxxx011010xxxxx1xx01111xxx
4652                                                      fmin.  */
4653                                                   return 639;
4654                                                 }
4655                                             }
4656                                           else
4657                                             {
4658                                               if (((word >> 16) & 0x1) == 0)
4659                                                 {
4660                                                   if (((word >> 20) & 0x1) == 0)
4661                                                     {
4662                                                       if (((word >> 28) & 0x1) == 0)
4663                                                         {
4664                                                           if (((word >> 29) & 0x1) == 0)
4665                                                             {
4666                                                               /* 33222222222211111111110000000000
4667                                                                  10987654321098765432109876543210
4668                                                                  xxxxxxxxxx0110110xxx01xx011100xx
4669                                                                  fcmeq.  */
4670                                                               return 171;
4671                                                             }
4672                                                           else
4673                                                             {
4674                                                               /* 33222222222211111111110000000000
4675                                                                  10987654321098765432109876543210
4676                                                                  xxxxxxxxxx0110110xxx01xx011101xx
4677                                                                  fcmle.  */
4678                                                               return 207;
4679                                                             }
4680                                                         }
4681                                                       else
4682                                                         {
4683                                                           if (((word >> 29) & 0x1) == 0)
4684                                                             {
4685                                                               /* 33222222222211111111110000000000
4686                                                                  10987654321098765432109876543210
4687                                                                  xxxxxxxxxx0110110xxx01xx011110xx
4688                                                                  fcmeq.  */
4689                                                               return 407;
4690                                                             }
4691                                                           else
4692                                                             {
4693                                                               /* 33222222222211111111110000000000
4694                                                                  10987654321098765432109876543210
4695                                                                  xxxxxxxxxx0110110xxx01xx011111xx
4696                                                                  fcmle.  */
4697                                                               return 426;
4698                                                             }
4699                                                         }
4700                                                     }
4701                                                   else
4702                                                     {
4703                                                       /* 33222222222211111111110000000000
4704                                                          10987654321098765432109876543210
4705                                                          xxxxxxxxxx0110110xxx11xx0111xxxx
4706                                                          faddp.  */
4707                                                       return 434;
4708                                                     }
4709                                                 }
4710                                               else
4711                                                 {
4712                                                   if (((word >> 23) & 0x1) == 0)
4713                                                     {
4714                                                       if (((word >> 28) & 0x1) == 0)
4715                                                         {
4716                                                           if (((word >> 29) & 0x1) == 0)
4717                                                             {
4718                                                               /* 33222222222211111111110000000000
4719                                                                  10987654321098765432109876543210
4720                                                                  xxxxxxxxxx0110111xxxx1x0011100xx
4721                                                                  scvtf.  */
4722                                                               return 169;
4723                                                             }
4724                                                           else
4725                                                             {
4726                                                               /* 33222222222211111111110000000000
4727                                                                  10987654321098765432109876543210
4728                                                                  xxxxxxxxxx0110111xxxx1x0011101xx
4729                                                                  ucvtf.  */
4730                                                               return 202;
4731                                                             }
4732                                                         }
4733                                                       else
4734                                                         {
4735                                                           if (((word >> 29) & 0x1) == 0)
4736                                                             {
4737                                                               /* 33222222222211111111110000000000
4738                                                                  10987654321098765432109876543210
4739                                                                  xxxxxxxxxx0110111xxxx1x0011110xx
4740                                                                  scvtf.  */
4741                                                               return 405;
4742                                                             }
4743                                                           else
4744                                                             {
4745                                                               /* 33222222222211111111110000000000
4746                                                                  10987654321098765432109876543210
4747                                                                  xxxxxxxxxx0110111xxxx1x0011111xx
4748                                                                  ucvtf.  */
4749                                                               return 424;
4750                                                             }
4751                                                         }
4752                                                     }
4753                                                   else
4754                                                     {
4755                                                       if (((word >> 28) & 0x1) == 0)
4756                                                         {
4757                                                           if (((word >> 29) & 0x1) == 0)
4758                                                             {
4759                                                               /* 33222222222211111111110000000000
4760                                                                  10987654321098765432109876543210
4761                                                                  xxxxxxxxxx0110111xxxx1x1011100xx
4762                                                                  frecpe.  */
4763                                                               return 179;
4764                                                             }
4765                                                           else
4766                                                             {
4767                                                               /* 33222222222211111111110000000000
4768                                                                  10987654321098765432109876543210
4769                                                                  xxxxxxxxxx0110111xxxx1x1011101xx
4770                                                                  frsqrte.  */
4771                                                               return 213;
4772                                                             }
4773                                                         }
4774                                                       else
4775                                                         {
4776                                                           if (((word >> 29) & 0x1) == 0)
4777                                                             {
4778                                                               /* 33222222222211111111110000000000
4779                                                                  10987654321098765432109876543210
4780                                                                  xxxxxxxxxx0110111xxxx1x1011110xx
4781                                                                  frecpe.  */
4782                                                               return 411;
4783                                                             }
4784                                                           else
4785                                                             {
4786                                                               /* 33222222222211111111110000000000
4787                                                                  10987654321098765432109876543210
4788                                                                  xxxxxxxxxx0110111xxxx1x1011111xx
4789                                                                  frsqrte.  */
4790                                                               return 429;
4791                                                             }
4792                                                         }
4793                                                     }
4794                                                 }
4795                                             }
4796                                         }
4797                                     }
4798                                   else
4799                                     {
4800                                       if (((word >> 14) & 0x1) == 0)
4801                                         {
4802                                           if (((word >> 15) & 0x1) == 0)
4803                                             {
4804                                               if (((word >> 28) & 0x1) == 0)
4805                                                 {
4806                                                   if (((word >> 16) & 0x1) == 0)
4807                                                     {
4808                                                       if (((word >> 20) & 0x1) == 0)
4809                                                         {
4810                                                           if (((word >> 29) & 0x1) == 0)
4811                                                             {
4812                                                               /* 33222222222211111111110000000000
4813                                                                  10987654321098765432109876543210
4814                                                                  xxxxxxxxxx0111000xxx01xx011100xx
4815                                                                  suqadd.  */
4816                                                               return 147;
4817                                                             }
4818                                                           else
4819                                                             {
4820                                                               /* 33222222222211111111110000000000
4821                                                                  10987654321098765432109876543210
4822                                                                  xxxxxxxxxx0111000xxx01xx011101xx
4823                                                                  usqadd.  */
4824                                                               return 182;
4825                                                             }
4826                                                         }
4827                                                       else
4828                                                         {
4829                                                           if (((word >> 29) & 0x1) == 0)
4830                                                             {
4831                                                               /* 33222222222211111111110000000000
4832                                                                  10987654321098765432109876543210
4833                                                                  xxxxxxxxxx0111000xxx11xx011100xx
4834                                                                  saddlv.  */
4835                                                               return 27;
4836                                                             }
4837                                                           else
4838                                                             {
4839                                                               /* 33222222222211111111110000000000
4840                                                                  10987654321098765432109876543210
4841                                                                  xxxxxxxxxx0111000xxx11xx011101xx
4842                                                                  uaddlv.  */
4843                                                               return 31;
4844                                                             }
4845                                                         }
4846                                                     }
4847                                                   else
4848                                                     {
4849                                                       if (((word >> 30) & 0x1) == 0)
4850                                                         {
4851                                                           /* 33222222222211111111110000000000
4852                                                              10987654321098765432109876543210
4853                                                              xxxxxxxxxx0111001xxxx1xx01110x0x
4854                                                              shll.  */
4855                                                           return 191;
4856                                                         }
4857                                                       else
4858                                                         {
4859                                                           /* 33222222222211111111110000000000
4860                                                              10987654321098765432109876543210
4861                                                              xxxxxxxxxx0111001xxxx1xx01110x1x
4862                                                              shll2.  */
4863                                                           return 192;
4864                                                         }
4865                                                     }
4866                                                 }
4867                                               else
4868                                                 {
4869                                                   if (((word >> 29) & 0x1) == 0)
4870                                                     {
4871                                                       if (((word >> 30) & 0x1) == 0)
4872                                                         {
4873                                                           /* 33222222222211111111110000000000
4874                                                              10987654321098765432109876543210
4875                                                              xxxxxxxxxx011100xxxxx1xx0111100x
4876                                                              fsub.  */
4877                                                           return 637;
4878                                                         }
4879                                                       else
4880                                                         {
4881                                                           /* 33222222222211111111110000000000
4882                                                              10987654321098765432109876543210
4883                                                              xxxxxxxxxx011100xxxxx1xx0111101x
4884                                                              suqadd.  */
4885                                                           return 395;
4886                                                         }
4887                                                     }
4888                                                   else
4889                                                     {
4890                                                       /* 33222222222211111111110000000000
4891                                                          10987654321098765432109876543210
4892                                                          xxxxxxxxxx011100xxxxx1xx011111xx
4893                                                          usqadd.  */
4894                                                       return 413;
4895                                                     }
4896                                                 }
4897                                             }
4898                                           else
4899                                             {
4900                                               if (((word >> 16) & 0x1) == 0)
4901                                                 {
4902                                                   if (((word >> 28) & 0x1) == 0)
4903                                                     {
4904                                                       if (((word >> 29) & 0x1) == 0)
4905                                                         {
4906                                                           /* 33222222222211111111110000000000
4907                                                              10987654321098765432109876543210
4908                                                              xxxxxxxxxx0111010xxxx1xx011100xx
4909                                                              abs.  */
4910                                                           return 155;
4911                                                         }
4912                                                       else
4913                                                         {
4914                                                           /* 33222222222211111111110000000000
4915                                                              10987654321098765432109876543210
4916                                                              xxxxxxxxxx0111010xxxx1xx011101xx
4917                                                              neg.  */
4918                                                           return 188;
4919                                                         }
4920                                                     }
4921                                                   else
4922                                                     {
4923                                                       if (((word >> 29) & 0x1) == 0)
4924                                                         {
4925                                                           /* 33222222222211111111110000000000
4926                                                              10987654321098765432109876543210
4927                                                              xxxxxxxxxx0111010xxxx1xx011110xx
4928                                                              abs.  */
4929                                                           return 400;
4930                                                         }
4931                                                       else
4932                                                         {
4933                                                           /* 33222222222211111111110000000000
4934                                                              10987654321098765432109876543210
4935                                                              xxxxxxxxxx0111010xxxx1xx011111xx
4936                                                              neg.  */
4937                                                           return 417;
4938                                                         }
4939                                                     }
4940                                                 }
4941                                               else
4942                                                 {
4943                                                   if (((word >> 20) & 0x1) == 0)
4944                                                     {
4945                                                       if (((word >> 23) & 0x1) == 0)
4946                                                         {
4947                                                           if (((word >> 28) & 0x1) == 0)
4948                                                             {
4949                                                               if (((word >> 29) & 0x1) == 0)
4950                                                                 {
4951                                                                   /* 33222222222211111111110000000000
4952                                                                      10987654321098765432109876543210
4953                                                                      xxxxxxxxxx0111011xxx01x0011100xx
4954                                                                      fcvtms.  */
4955                                                                   return 167;
4956                                                                 }
4957                                                               else
4958                                                                 {
4959                                                                   /* 33222222222211111111110000000000
4960                                                                      10987654321098765432109876543210
4961                                                                      xxxxxxxxxx0111011xxx01x0011101xx
4962                                                                      fcvtmu.  */
4963                                                                   return 200;
4964                                                                 }
4965                                                             }
4966                                                           else
4967                                                             {
4968                                                               if (((word >> 29) & 0x1) == 0)
4969                                                                 {
4970                                                                   /* 33222222222211111111110000000000
4971                                                                      10987654321098765432109876543210
4972                                                                      xxxxxxxxxx0111011xxx01x0011110xx
4973                                                                      fcvtms.  */
4974                                                                   return 403;
4975                                                                 }
4976                                                               else
4977                                                                 {
4978                                                                   /* 33222222222211111111110000000000
4979                                                                      10987654321098765432109876543210
4980                                                                      xxxxxxxxxx0111011xxx01x0011111xx
4981                                                                      fcvtmu.  */
4982                                                                   return 422;
4983                                                                 }
4984                                                             }
4985                                                         }
4986                                                       else
4987                                                         {
4988                                                           if (((word >> 28) & 0x1) == 0)
4989                                                             {
4990                                                               if (((word >> 29) & 0x1) == 0)
4991                                                                 {
4992                                                                   /* 33222222222211111111110000000000
4993                                                                      10987654321098765432109876543210
4994                                                                      xxxxxxxxxx0111011xxx01x1011100xx
4995                                                                      fcvtzs.  */
4996                                                                   return 177;
4997                                                                 }
4998                                                               else
4999                                                                 {
5000                                                                   /* 33222222222211111111110000000000
5001                                                                      10987654321098765432109876543210
5002                                                                      xxxxxxxxxx0111011xxx01x1011101xx
5003                                                                      fcvtzu.  */
5004                                                                   return 211;
5005                                                                 }
5006                                                             }
5007                                                           else
5008                                                             {
5009                                                               if (((word >> 29) & 0x1) == 0)
5010                                                                 {
5011                                                                   /* 33222222222211111111110000000000
5012                                                                      10987654321098765432109876543210
5013                                                                      xxxxxxxxxx0111011xxx01x1011110xx
5014                                                                      fcvtzs.  */
5015                                                                   return 410;
5016                                                                 }
5017                                                               else
5018                                                                 {
5019                                                                   /* 33222222222211111111110000000000
5020                                                                      10987654321098765432109876543210
5021                                                                      xxxxxxxxxx0111011xxx01x1011111xx
5022                                                                      fcvtzu.  */
5023                                                                   return 428;
5024                                                                 }
5025                                                             }
5026                                                         }
5027                                                     }
5028                                                   else
5029                                                     {
5030                                                       if (((word >> 28) & 0x1) == 0)
5031                                                         {
5032                                                           /* 33222222222211111111110000000000
5033                                                              10987654321098765432109876543210
5034                                                              xxxxxxxxxx0111011xxx11xx01110xxx
5035                                                              addv.  */
5036                                                           return 30;
5037                                                         }
5038                                                       else
5039                                                         {
5040                                                           /* 33222222222211111111110000000000
5041                                                              10987654321098765432109876543210
5042                                                              xxxxxxxxxx0111011xxx11xx01111xxx
5043                                                              addp.  */
5044                                                           return 432;
5045                                                         }
5046                                                     }
5047                                                 }
5048                                             }
5049                                         }
5050                                       else
5051                                         {
5052                                           if (((word >> 15) & 0x1) == 0)
5053                                             {
5054                                               if (((word >> 28) & 0x1) == 0)
5055                                                 {
5056                                                   if (((word >> 16) & 0x1) == 0)
5057                                                     {
5058                                                       if (((word >> 19) & 0x1) == 0)
5059                                                         {
5060                                                           if (((word >> 29) & 0x1) == 0)
5061                                                             {
5062                                                               /* 33222222222211111111110000000000
5063                                                                  10987654321098765432109876543210
5064                                                                  xxxxxxxxxx0111100xx0x1xx011100xx
5065                                                                  sqabs.  */
5066                                                               return 151;
5067                                                             }
5068                                                           else
5069                                                             {
5070                                                               /* 33222222222211111111110000000000
5071                                                                  10987654321098765432109876543210
5072                                                                  xxxxxxxxxx0111100xx0x1xx011101xx
5073                                                                  sqneg.  */
5074                                                               return 185;
5075                                                             }
5076                                                         }
5077                                                       else
5078                                                         {
5079                                                           /* 33222222222211111111110000000000
5080                                                              10987654321098765432109876543210
5081                                                              xxxxxxxxxx0111100xx1x1xx01110xxx
5082                                                              aesimc.  */
5083                                                           return 536;
5084                                                         }
5085                                                     }
5086                                                   else
5087                                                     {
5088                                                       if (((word >> 30) & 0x1) == 0)
5089                                                         {
5090                                                           /* 33222222222211111111110000000000
5091                                                              10987654321098765432109876543210
5092                                                              xxxxxxxxxx0111101xxxx1xx01110x0x
5093                                                              fcvtl.  */
5094                                                           return 162;
5095                                                         }
5096                                                       else
5097                                                         {
5098                                                           /* 33222222222211111111110000000000
5099                                                              10987654321098765432109876543210
5100                                                              xxxxxxxxxx0111101xxxx1xx01110x1x
5101                                                              fcvtl2.  */
5102                                                           return 163;
5103                                                         }
5104                                                     }
5105                                                 }
5106                                               else
5107                                                 {
5108                                                   if (((word >> 29) & 0x1) == 0)
5109                                                     {
5110                                                       if (((word >> 30) & 0x1) == 0)
5111                                                         {
5112                                                           /* 33222222222211111111110000000000
5113                                                              10987654321098765432109876543210
5114                                                              xxxxxxxxxx011110xxxxx1xx0111100x
5115                                                              fminnm.  */
5116                                                           return 641;
5117                                                         }
5118                                                       else
5119                                                         {
5120                                                           /* 33222222222211111111110000000000
5121                                                              10987654321098765432109876543210
5122                                                              xxxxxxxxxx011110xxxxx1xx0111101x
5123                                                              sqabs.  */
5124                                                           return 396;
5125                                                         }
5126                                                     }
5127                                                   else
5128                                                     {
5129                                                       /* 33222222222211111111110000000000
5130                                                          10987654321098765432109876543210
5131                                                          xxxxxxxxxx011110xxxxx1xx011111xx
5132                                                          sqneg.  */
5133                                                       return 414;
5134                                                     }
5135                                                 }
5136                                             }
5137                                           else
5138                                             {
5139                                               if (((word >> 16) & 0x1) == 0)
5140                                                 {
5141                                                   if (((word >> 20) & 0x1) == 0)
5142                                                     {
5143                                                       if (((word >> 29) & 0x1) == 0)
5144                                                         {
5145                                                           /* 33222222222211111111110000000000
5146                                                              10987654321098765432109876543210
5147                                                              xxxxxxxxxx0111110xxx01xx0111x0xx
5148                                                              fabs.  */
5149                                                           return 173;
5150                                                         }
5151                                                       else
5152                                                         {
5153                                                           /* 33222222222211111111110000000000
5154                                                              10987654321098765432109876543210
5155                                                              xxxxxxxxxx0111110xxx01xx0111x1xx
5156                                                              fneg.  */
5157                                                           return 208;
5158                                                         }
5159                                                     }
5160                                                   else
5161                                                     {
5162                                                       if (((word >> 23) & 0x1) == 0)
5163                                                         {
5164                                                           if (((word >> 28) & 0x1) == 0)
5165                                                             {
5166                                                               /* 33222222222211111111110000000000
5167                                                                  10987654321098765432109876543210
5168                                                                  xxxxxxxxxx0111110xxx11x001110xxx
5169                                                                  fmaxv.  */
5170                                                               return 35;
5171                                                             }
5172                                                           else
5173                                                             {
5174                                                               /* 33222222222211111111110000000000
5175                                                                  10987654321098765432109876543210
5176                                                                  xxxxxxxxxx0111110xxx11x001111xxx
5177                                                                  fmaxp.  */
5178                                                               return 435;
5179                                                             }
5180                                                         }
5181                                                       else
5182                                                         {
5183                                                           if (((word >> 28) & 0x1) == 0)
5184                                                             {
5185                                                               /* 33222222222211111111110000000000
5186                                                                  10987654321098765432109876543210
5187                                                                  xxxxxxxxxx0111110xxx11x101110xxx
5188                                                                  fminv.  */
5189                                                               return 37;
5190                                                             }
5191                                                           else
5192                                                             {
5193                                                               /* 33222222222211111111110000000000
5194                                                                  10987654321098765432109876543210
5195                                                                  xxxxxxxxxx0111110xxx11x101111xxx
5196                                                                  fminp.  */
5197                                                               return 437;
5198                                                             }
5199                                                         }
5200                                                     }
5201                                                 }
5202                                               else
5203                                                 {
5204                                                   if (((word >> 28) & 0x1) == 0)
5205                                                     {
5206                                                       /* 33222222222211111111110000000000
5207                                                          10987654321098765432109876543210
5208                                                          xxxxxxxxxx0111111xxxx1xx01110xxx
5209                                                          fsqrt.  */
5210                                                       return 214;
5211                                                     }
5212                                                   else
5213                                                     {
5214                                                       /* 33222222222211111111110000000000
5215                                                          10987654321098765432109876543210
5216                                                          xxxxxxxxxx0111111xxxx1xx01111xxx
5217                                                          frecpx.  */
5218                                                       return 412;
5219                                                     }
5220                                                 }
5221                                             }
5222                                         }
5223                                     }
5224                                 }
5225                             }
5226                         }
5227                       else
5228                         {
5229                           if (((word >> 11) & 0x1) == 0)
5230                             {
5231                               if (((word >> 28) & 0x1) == 0)
5232                                 {
5233                                   if (((word >> 12) & 0x1) == 0)
5234                                     {
5235                                       if (((word >> 13) & 0x1) == 0)
5236                                         {
5237                                           if (((word >> 14) & 0x1) == 0)
5238                                             {
5239                                               if (((word >> 15) & 0x1) == 0)
5240                                                 {
5241                                                   if (((word >> 29) & 0x1) == 0)
5242                                                     {
5243                                                       /* 33222222222211111111110000000000
5244                                                          10987654321098765432109876543210
5245                                                          xxxxxxxxxx100000xxxxx1xx011100xx
5246                                                          shadd.  */
5247                                                       return 221;
5248                                                     }
5249                                                   else
5250                                                     {
5251                                                       /* 33222222222211111111110000000000
5252                                                          10987654321098765432109876543210
5253                                                          xxxxxxxxxx100000xxxxx1xx011101xx
5254                                                          uhadd.  */
5255                                                       return 261;
5256                                                     }
5257                                                 }
5258                                               else
5259                                                 {
5260                                                   if (((word >> 29) & 0x1) == 0)
5261                                                     {
5262                                                       /* 33222222222211111111110000000000
5263                                                          10987654321098765432109876543210
5264                                                          xxxxxxxxxx100001xxxxx1xx011100xx
5265                                                          add.  */
5266                                                       return 236;
5267                                                     }
5268                                                   else
5269                                                     {
5270                                                       /* 33222222222211111111110000000000
5271                                                          10987654321098765432109876543210
5272                                                          xxxxxxxxxx100001xxxxx1xx011101xx
5273                                                          sub.  */
5274                                                       return 276;
5275                                                     }
5276                                                 }
5277                                             }
5278                                           else
5279                                             {
5280                                               if (((word >> 15) & 0x1) == 0)
5281                                                 {
5282                                                   if (((word >> 29) & 0x1) == 0)
5283                                                     {
5284                                                       /* 33222222222211111111110000000000
5285                                                          10987654321098765432109876543210
5286                                                          xxxxxxxxxx100010xxxxx1xx011100xx
5287                                                          sshl.  */
5288                                                       return 228;
5289                                                     }
5290                                                   else
5291                                                     {
5292                                                       /* 33222222222211111111110000000000
5293                                                          10987654321098765432109876543210
5294                                                          xxxxxxxxxx100010xxxxx1xx011101xx
5295                                                          ushl.  */
5296                                                       return 268;
5297                                                     }
5298                                                 }
5299                                               else
5300                                                 {
5301                                                   if (((word >> 23) & 0x1) == 0)
5302                                                     {
5303                                                       if (((word >> 29) & 0x1) == 0)
5304                                                         {
5305                                                           /* 33222222222211111111110000000000
5306                                                              10987654321098765432109876543210
5307                                                              xxxxxxxxxx100011xxxxx1x0011100xx
5308                                                              fmaxnm.  */
5309                                                           return 244;
5310                                                         }
5311                                                       else
5312                                                         {
5313                                                           /* 33222222222211111111110000000000
5314                                                              10987654321098765432109876543210
5315                                                              xxxxxxxxxx100011xxxxx1x0011101xx
5316                                                              fmaxnmp.  */
5317                                                           return 283;
5318                                                         }
5319                                                     }
5320                                                   else
5321                                                     {
5322                                                       if (((word >> 29) & 0x1) == 0)
5323                                                         {
5324                                                           /* 33222222222211111111110000000000
5325                                                              10987654321098765432109876543210
5326                                                              xxxxxxxxxx100011xxxxx1x1011100xx
5327                                                              fminnm.  */
5328                                                           return 253;
5329                                                         }
5330                                                       else
5331                                                         {
5332                                                           /* 33222222222211111111110000000000
5333                                                              10987654321098765432109876543210
5334                                                              xxxxxxxxxx100011xxxxx1x1011101xx
5335                                                              fminnmp.  */
5336                                                           return 292;
5337                                                         }
5338                                                     }
5339                                                 }
5340                                             }
5341                                         }
5342                                       else
5343                                         {
5344                                           if (((word >> 14) & 0x1) == 0)
5345                                             {
5346                                               if (((word >> 15) & 0x1) == 0)
5347                                                 {
5348                                                   if (((word >> 29) & 0x1) == 0)
5349                                                     {
5350                                                       /* 33222222222211111111110000000000
5351                                                          10987654321098765432109876543210
5352                                                          xxxxxxxxxx100100xxxxx1xx011100xx
5353                                                          shsub.  */
5354                                                       return 224;
5355                                                     }
5356                                                   else
5357                                                     {
5358                                                       /* 33222222222211111111110000000000
5359                                                          10987654321098765432109876543210
5360                                                          xxxxxxxxxx100100xxxxx1xx011101xx
5361                                                          uhsub.  */
5362                                                       return 264;
5363                                                     }
5364                                                 }
5365                                               else
5366                                                 {
5367                                                   if (((word >> 29) & 0x1) == 0)
5368                                                     {
5369                                                       /* 33222222222211111111110000000000
5370                                                          10987654321098765432109876543210
5371                                                          xxxxxxxxxx100101xxxxx1xx011100xx
5372                                                          smaxp.  */
5373                                                       return 240;
5374                                                     }
5375                                                   else
5376                                                     {
5377                                                       /* 33222222222211111111110000000000
5378                                                          10987654321098765432109876543210
5379                                                          xxxxxxxxxx100101xxxxx1xx011101xx
5380                                                          umaxp.  */
5381                                                       return 280;
5382                                                     }
5383                                                 }
5384                                             }
5385                                           else
5386                                             {
5387                                               if (((word >> 15) & 0x1) == 0)
5388                                                 {
5389                                                   if (((word >> 29) & 0x1) == 0)
5390                                                     {
5391                                                       /* 33222222222211111111110000000000
5392                                                          10987654321098765432109876543210
5393                                                          xxxxxxxxxx100110xxxxx1xx011100xx
5394                                                          smax.  */
5395                                                       return 232;
5396                                                     }
5397                                                   else
5398                                                     {
5399                                                       /* 33222222222211111111110000000000
5400                                                          10987654321098765432109876543210
5401                                                          xxxxxxxxxx100110xxxxx1xx011101xx
5402                                                          umax.  */
5403                                                       return 272;
5404                                                     }
5405                                                 }
5406                                               else
5407                                                 {
5408                                                   if (((word >> 23) & 0x1) == 0)
5409                                                     {
5410                                                       if (((word >> 29) & 0x1) == 0)
5411                                                         {
5412                                                           /* 33222222222211111111110000000000
5413                                                              10987654321098765432109876543210
5414                                                              xxxxxxxxxx100111xxxxx1x0011100xx
5415                                                              fcmeq.  */
5416                                                           return 248;
5417                                                         }
5418                                                       else
5419                                                         {
5420                                                           /* 33222222222211111111110000000000
5421                                                              10987654321098765432109876543210
5422                                                              xxxxxxxxxx100111xxxxx1x0011101xx
5423                                                              fcmge.  */
5424                                                           return 286;
5425                                                         }
5426                                                     }
5427                                                   else
5428                                                     {
5429                                                       /* 33222222222211111111110000000000
5430                                                          10987654321098765432109876543210
5431                                                          xxxxxxxxxx100111xxxxx1x101110xxx
5432                                                          fcmgt.  */
5433                                                       return 294;
5434                                                     }
5435                                                 }
5436                                             }
5437                                         }
5438                                     }
5439                                   else
5440                                     {
5441                                       if (((word >> 13) & 0x1) == 0)
5442                                         {
5443                                           if (((word >> 14) & 0x1) == 0)
5444                                             {
5445                                               if (((word >> 15) & 0x1) == 0)
5446                                                 {
5447                                                   if (((word >> 29) & 0x1) == 0)
5448                                                     {
5449                                                       /* 33222222222211111111110000000000
5450                                                          10987654321098765432109876543210
5451                                                          xxxxxxxxxx101000xxxxx1xx011100xx
5452                                                          srhadd.  */
5453                                                       return 223;
5454                                                     }
5455                                                   else
5456                                                     {
5457                                                       /* 33222222222211111111110000000000
5458                                                          10987654321098765432109876543210
5459                                                          xxxxxxxxxx101000xxxxx1xx011101xx
5460                                                          urhadd.  */
5461                                                       return 263;
5462                                                     }
5463                                                 }
5464                                               else
5465                                                 {
5466                                                   if (((word >> 29) & 0x1) == 0)
5467                                                     {
5468                                                       /* 33222222222211111111110000000000
5469                                                          10987654321098765432109876543210
5470                                                          xxxxxxxxxx101001xxxxx1xx011100xx
5471                                                          mla.  */
5472                                                       return 238;
5473                                                     }
5474                                                   else
5475                                                     {
5476                                                       /* 33222222222211111111110000000000
5477                                                          10987654321098765432109876543210
5478                                                          xxxxxxxxxx101001xxxxx1xx011101xx
5479                                                          mls.  */
5480                                                       return 278;
5481                                                     }
5482                                                 }
5483                                             }
5484                                           else
5485                                             {
5486                                               if (((word >> 15) & 0x1) == 0)
5487                                                 {
5488                                                   if (((word >> 29) & 0x1) == 0)
5489                                                     {
5490                                                       /* 33222222222211111111110000000000
5491                                                          10987654321098765432109876543210
5492                                                          xxxxxxxxxx101010xxxxx1xx011100xx
5493                                                          srshl.  */
5494                                                       return 230;
5495                                                     }
5496                                                   else
5497                                                     {
5498                                                       /* 33222222222211111111110000000000
5499                                                          10987654321098765432109876543210
5500                                                          xxxxxxxxxx101010xxxxx1xx011101xx
5501                                                          urshl.  */
5502                                                       return 270;
5503                                                     }
5504                                                 }
5505                                               else
5506                                                 {
5507                                                   if (((word >> 23) & 0x1) == 0)
5508                                                     {
5509                                                       if (((word >> 29) & 0x1) == 0)
5510                                                         {
5511                                                           /* 33222222222211111111110000000000
5512                                                              10987654321098765432109876543210
5513                                                              xxxxxxxxxx101011xxxxx1x0011100xx
5514                                                              fadd.  */
5515                                                           return 246;
5516                                                         }
5517                                                       else
5518                                                         {
5519                                                           /* 33222222222211111111110000000000
5520                                                              10987654321098765432109876543210
5521                                                              xxxxxxxxxx101011xxxxx1x0011101xx
5522                                                              faddp.  */
5523                                                           return 284;
5524                                                         }
5525                                                     }
5526                                                   else
5527                                                     {
5528                                                       if (((word >> 29) & 0x1) == 0)
5529                                                         {
5530                                                           /* 33222222222211111111110000000000
5531                                                              10987654321098765432109876543210
5532                                                              xxxxxxxxxx101011xxxxx1x1011100xx
5533                                                              fsub.  */
5534                                                           return 255;
5535                                                         }
5536                                                       else
5537                                                         {
5538                                                           /* 33222222222211111111110000000000
5539                                                              10987654321098765432109876543210
5540                                                              xxxxxxxxxx101011xxxxx1x1011101xx
5541                                                              fabd.  */
5542                                                           return 293;
5543                                                         }
5544                                                     }
5545                                                 }
5546                                             }
5547                                         }
5548                                       else
5549                                         {
5550                                           if (((word >> 14) & 0x1) == 0)
5551                                             {
5552                                               if (((word >> 15) & 0x1) == 0)
5553                                                 {
5554                                                   if (((word >> 29) & 0x1) == 0)
5555                                                     {
5556                                                       /* 33222222222211111111110000000000
5557                                                          10987654321098765432109876543210
5558                                                          xxxxxxxxxx101100xxxxx1xx011100xx
5559                                                          cmgt.  */
5560                                                       return 226;
5561                                                     }
5562                                                   else
5563                                                     {
5564                                                       /* 33222222222211111111110000000000
5565                                                          10987654321098765432109876543210
5566                                                          xxxxxxxxxx101100xxxxx1xx011101xx
5567                                                          cmhi.  */
5568                                                       return 266;
5569                                                     }
5570                                                 }
5571                                               else
5572                                                 {
5573                                                   if (((word >> 29) & 0x1) == 0)
5574                                                     {
5575                                                       /* 33222222222211111111110000000000
5576                                                          10987654321098765432109876543210
5577                                                          xxxxxxxxxx101101xxxxx1xx011100xx
5578                                                          sqdmulh.  */
5579                                                       return 242;
5580                                                     }
5581                                                   else
5582                                                     {
5583                                                       /* 33222222222211111111110000000000
5584                                                          10987654321098765432109876543210
5585                                                          xxxxxxxxxx101101xxxxx1xx011101xx
5586                                                          sqrdmulh.  */
5587                                                       return 282;
5588                                                     }
5589                                                 }
5590                                             }
5591                                           else
5592                                             {
5593                                               if (((word >> 15) & 0x1) == 0)
5594                                                 {
5595                                                   if (((word >> 29) & 0x1) == 0)
5596                                                     {
5597                                                       /* 33222222222211111111110000000000
5598                                                          10987654321098765432109876543210
5599                                                          xxxxxxxxxx101110xxxxx1xx011100xx
5600                                                          sabd.  */
5601                                                       return 234;
5602                                                     }
5603                                                   else
5604                                                     {
5605                                                       /* 33222222222211111111110000000000
5606                                                          10987654321098765432109876543210
5607                                                          xxxxxxxxxx101110xxxxx1xx011101xx
5608                                                          uabd.  */
5609                                                       return 274;
5610                                                     }
5611                                                 }
5612                                               else
5613                                                 {
5614                                                   if (((word >> 23) & 0x1) == 0)
5615                                                     {
5616                                                       if (((word >> 29) & 0x1) == 0)
5617                                                         {
5618                                                           /* 33222222222211111111110000000000
5619                                                              10987654321098765432109876543210
5620                                                              xxxxxxxxxx101111xxxxx1x0011100xx
5621                                                              fmax.  */
5622                                                           return 249;
5623                                                         }
5624                                                       else
5625                                                         {
5626                                                           /* 33222222222211111111110000000000
5627                                                              10987654321098765432109876543210
5628                                                              xxxxxxxxxx101111xxxxx1x0011101xx
5629                                                              fmaxp.  */
5630                                                           return 288;
5631                                                         }
5632                                                     }
5633                                                   else
5634                                                     {
5635                                                       if (((word >> 29) & 0x1) == 0)
5636                                                         {
5637                                                           /* 33222222222211111111110000000000
5638                                                              10987654321098765432109876543210
5639                                                              xxxxxxxxxx101111xxxxx1x1011100xx
5640                                                              fmin.  */
5641                                                           return 256;
5642                                                         }
5643                                                       else
5644                                                         {
5645                                                           /* 33222222222211111111110000000000
5646                                                              10987654321098765432109876543210
5647                                                              xxxxxxxxxx101111xxxxx1x1011101xx
5648                                                              fminp.  */
5649                                                           return 296;
5650                                                         }
5651                                                     }
5652                                                 }
5653                                             }
5654                                         }
5655                                     }
5656                                 }
5657                               else
5658                                 {
5659                                   if (((word >> 29) & 0x1) == 0)
5660                                     {
5661                                       if (((word >> 30) & 0x1) == 0)
5662                                         {
5663                                           if (((word >> 4) & 0x1) == 0)
5664                                             {
5665                                               /* 33222222222211111111110000000000
5666                                                  10987654321098765432109876543210
5667                                                  xxxx0xxxxx10xxxxxxxxx1xx0111100x
5668                                                  fccmp.  */
5669                                               return 616;
5670                                             }
5671                                           else
5672                                             {
5673                                               /* 33222222222211111111110000000000
5674                                                  10987654321098765432109876543210
5675                                                  xxxx1xxxxx10xxxxxxxxx1xx0111100x
5676                                                  fccmpe.  */
5677                                               return 617;
5678                                             }
5679                                         }
5680                                       else
5681                                         {
5682                                           if (((word >> 12) & 0x1) == 0)
5683                                             {
5684                                               if (((word >> 13) & 0x1) == 0)
5685                                                 {
5686                                                   if (((word >> 14) & 0x1) == 0)
5687                                                     {
5688                                                       /* 33222222222211111111110000000000
5689                                                          10987654321098765432109876543210
5690                                                          xxxxxxxxxx10000xxxxxx1xx0111101x
5691                                                          add.  */
5692                                                       return 451;
5693                                                     }
5694                                                   else
5695                                                     {
5696                                                       /* 33222222222211111111110000000000
5697                                                          10987654321098765432109876543210
5698                                                          xxxxxxxxxx10001xxxxxx1xx0111101x
5699                                                          sshl.  */
5700                                                       return 449;
5701                                                     }
5702                                                 }
5703                                               else
5704                                                 {
5705                                                   /* 33222222222211111111110000000000
5706                                                      10987654321098765432109876543210
5707                                                      xxxxxxxxxx1001xxxxxxx1xx0111101x
5708                                                      fcmeq.  */
5709                                                   return 444;
5710                                                 }
5711                                             }
5712                                           else
5713                                             {
5714                                               if (((word >> 13) & 0x1) == 0)
5715                                                 {
5716                                                   /* 33222222222211111111110000000000
5717                                                      10987654321098765432109876543210
5718                                                      xxxxxxxxxx1010xxxxxxx1xx0111101x
5719                                                      srshl.  */
5720                                                   return 450;
5721                                                 }
5722                                               else
5723                                                 {
5724                                                   if (((word >> 15) & 0x1) == 0)
5725                                                     {
5726                                                       /* 33222222222211111111110000000000
5727                                                          10987654321098765432109876543210
5728                                                          xxxxxxxxxx1011x0xxxxx1xx0111101x
5729                                                          cmgt.  */
5730                                                       return 447;
5731                                                     }
5732                                                   else
5733                                                     {
5734                                                       /* 33222222222211111111110000000000
5735                                                          10987654321098765432109876543210
5736                                                          xxxxxxxxxx1011x1xxxxx1xx0111101x
5737                                                          sqdmulh.  */
5738                                                       return 442;
5739                                                     }
5740                                                 }
5741                                             }
5742                                         }
5743                                     }
5744                                   else
5745                                     {
5746                                       if (((word >> 12) & 0x1) == 0)
5747                                         {
5748                                           if (((word >> 13) & 0x1) == 0)
5749                                             {
5750                                               if (((word >> 14) & 0x1) == 0)
5751                                                 {
5752                                                   /* 33222222222211111111110000000000
5753                                                      10987654321098765432109876543210
5754                                                      xxxxxxxxxx10000xxxxxx1xx011111xx
5755                                                      sub.  */
5756                                                   return 467;
5757                                                 }
5758                                               else
5759                                                 {
5760                                                   /* 33222222222211111111110000000000
5761                                                      10987654321098765432109876543210
5762                                                      xxxxxxxxxx10001xxxxxx1xx011111xx
5763                                                      ushl.  */
5764                                                   return 465;
5765                                                 }
5766                                             }
5767                                           else
5768                                             {
5769                                               if (((word >> 23) & 0x1) == 0)
5770                                                 {
5771                                                   /* 33222222222211111111110000000000
5772                                                      10987654321098765432109876543210
5773                                                      xxxxxxxxxx1001xxxxxxx1x0011111xx
5774                                                      fcmge.  */
5775                                                   return 458;
5776                                                 }
5777                                               else
5778                                                 {
5779                                                   /* 33222222222211111111110000000000
5780                                                      10987654321098765432109876543210
5781                                                      xxxxxxxxxx1001xxxxxxx1x1011111xx
5782                                                      fcmgt.  */
5783                                                   return 461;
5784                                                 }
5785                                             }
5786                                         }
5787                                       else
5788                                         {
5789                                           if (((word >> 13) & 0x1) == 0)
5790                                             {
5791                                               if (((word >> 15) & 0x1) == 0)
5792                                                 {
5793                                                   /* 33222222222211111111110000000000
5794                                                      10987654321098765432109876543210
5795                                                      xxxxxxxxxx1010x0xxxxx1xx011111xx
5796                                                      urshl.  */
5797                                                   return 466;
5798                                                 }
5799                                               else
5800                                                 {
5801                                                   /* 33222222222211111111110000000000
5802                                                      10987654321098765432109876543210
5803                                                      xxxxxxxxxx1010x1xxxxx1xx011111xx
5804                                                      fabd.  */
5805                                                   return 460;
5806                                                 }
5807                                             }
5808                                           else
5809                                             {
5810                                               if (((word >> 15) & 0x1) == 0)
5811                                                 {
5812                                                   /* 33222222222211111111110000000000
5813                                                      10987654321098765432109876543210
5814                                                      xxxxxxxxxx1011x0xxxxx1xx011111xx
5815                                                      cmhi.  */
5816                                                   return 463;
5817                                                 }
5818                                               else
5819                                                 {
5820                                                   /* 33222222222211111111110000000000
5821                                                      10987654321098765432109876543210
5822                                                      xxxxxxxxxx1011x1xxxxx1xx011111xx
5823                                                      sqrdmulh.  */
5824                                                   return 457;
5825                                                 }
5826                                             }
5827                                         }
5828                                     }
5829                                 }
5830                             }
5831                           else
5832                             {
5833                               if (((word >> 28) & 0x1) == 0)
5834                                 {
5835                                   if (((word >> 12) & 0x1) == 0)
5836                                     {
5837                                       if (((word >> 13) & 0x1) == 0)
5838                                         {
5839                                           if (((word >> 14) & 0x1) == 0)
5840                                             {
5841                                               if (((word >> 15) & 0x1) == 0)
5842                                                 {
5843                                                   if (((word >> 29) & 0x1) == 0)
5844                                                     {
5845                                                       /* 33222222222211111111110000000000
5846                                                          10987654321098765432109876543210
5847                                                          xxxxxxxxxx110000xxxxx1xx011100xx
5848                                                          sqadd.  */
5849                                                       return 222;
5850                                                     }
5851                                                   else
5852                                                     {
5853                                                       /* 33222222222211111111110000000000
5854                                                          10987654321098765432109876543210
5855                                                          xxxxxxxxxx110000xxxxx1xx011101xx
5856                                                          uqadd.  */
5857                                                       return 262;
5858                                                     }
5859                                                 }
5860                                               else
5861                                                 {
5862                                                   if (((word >> 29) & 0x1) == 0)
5863                                                     {
5864                                                       /* 33222222222211111111110000000000
5865                                                          10987654321098765432109876543210
5866                                                          xxxxxxxxxx110001xxxxx1xx011100xx
5867                                                          cmtst.  */
5868                                                       return 237;
5869                                                     }
5870                                                   else
5871                                                     {
5872                                                       /* 33222222222211111111110000000000
5873                                                          10987654321098765432109876543210
5874                                                          xxxxxxxxxx110001xxxxx1xx011101xx
5875                                                          cmeq.  */
5876                                                       return 277;
5877                                                     }
5878                                                 }
5879                                             }
5880                                           else
5881                                             {
5882                                               if (((word >> 15) & 0x1) == 0)
5883                                                 {
5884                                                   if (((word >> 29) & 0x1) == 0)
5885                                                     {
5886                                                       /* 33222222222211111111110000000000
5887                                                          10987654321098765432109876543210
5888                                                          xxxxxxxxxx110010xxxxx1xx011100xx
5889                                                          sqshl.  */
5890                                                       return 229;
5891                                                     }
5892                                                   else
5893                                                     {
5894                                                       /* 33222222222211111111110000000000
5895                                                          10987654321098765432109876543210
5896                                                          xxxxxxxxxx110010xxxxx1xx011101xx
5897                                                          uqshl.  */
5898                                                       return 269;
5899                                                     }
5900                                                 }
5901                                               else
5902                                                 {
5903                                                   if (((word >> 23) & 0x1) == 0)
5904                                                     {
5905                                                       /* 33222222222211111111110000000000
5906                                                          10987654321098765432109876543210
5907                                                          xxxxxxxxxx110011xxxxx1x001110xxx
5908                                                          fmla.  */
5909                                                       return 245;
5910                                                     }
5911                                                   else
5912                                                     {
5913                                                       /* 33222222222211111111110000000000
5914                                                          10987654321098765432109876543210
5915                                                          xxxxxxxxxx110011xxxxx1x101110xxx
5916                                                          fmls.  */
5917                                                       return 254;
5918                                                     }
5919                                                 }
5920                                             }
5921                                         }
5922                                       else
5923                                         {
5924                                           if (((word >> 14) & 0x1) == 0)
5925                                             {
5926                                               if (((word >> 15) & 0x1) == 0)
5927                                                 {
5928                                                   if (((word >> 29) & 0x1) == 0)
5929                                                     {
5930                                                       /* 33222222222211111111110000000000
5931                                                          10987654321098765432109876543210
5932                                                          xxxxxxxxxx110100xxxxx1xx011100xx
5933                                                          sqsub.  */
5934                                                       return 225;
5935                                                     }
5936                                                   else
5937                                                     {
5938                                                       /* 33222222222211111111110000000000
5939                                                          10987654321098765432109876543210
5940                                                          xxxxxxxxxx110100xxxxx1xx011101xx
5941                                                          uqsub.  */
5942                                                       return 265;
5943                                                     }
5944                                                 }
5945                                               else
5946                                                 {
5947                                                   if (((word >> 29) & 0x1) == 0)
5948                                                     {
5949                                                       /* 33222222222211111111110000000000
5950                                                          10987654321098765432109876543210
5951                                                          xxxxxxxxxx110101xxxxx1xx011100xx
5952                                                          sminp.  */
5953                                                       return 241;
5954                                                     }
5955                                                   else
5956                                                     {
5957                                                       /* 33222222222211111111110000000000
5958                                                          10987654321098765432109876543210
5959                                                          xxxxxxxxxx110101xxxxx1xx011101xx
5960                                                          uminp.  */
5961                                                       return 281;
5962                                                     }
5963                                                 }
5964                                             }
5965                                           else
5966                                             {
5967                                               if (((word >> 15) & 0x1) == 0)
5968                                                 {
5969                                                   if (((word >> 29) & 0x1) == 0)
5970                                                     {
5971                                                       /* 33222222222211111111110000000000
5972                                                          10987654321098765432109876543210
5973                                                          xxxxxxxxxx110110xxxxx1xx011100xx
5974                                                          smin.  */
5975                                                       return 233;
5976                                                     }
5977                                                   else
5978                                                     {
5979                                                       /* 33222222222211111111110000000000
5980                                                          10987654321098765432109876543210
5981                                                          xxxxxxxxxx110110xxxxx1xx011101xx
5982                                                          umin.  */
5983                                                       return 273;
5984                                                     }
5985                                                 }
5986                                               else
5987                                                 {
5988                                                   if (((word >> 23) & 0x1) == 0)
5989                                                     {
5990                                                       /* 33222222222211111111110000000000
5991                                                          10987654321098765432109876543210
5992                                                          xxxxxxxxxx110111xxxxx1x001110xxx
5993                                                          facge.  */
5994                                                       return 287;
5995                                                     }
5996                                                   else
5997                                                     {
5998                                                       /* 33222222222211111111110000000000
5999                                                          10987654321098765432109876543210
6000                                                          xxxxxxxxxx110111xxxxx1x101110xxx
6001                                                          facgt.  */
6002                                                       return 295;
6003                                                     }
6004                                                 }
6005                                             }
6006                                         }
6007                                     }
6008                                   else
6009                                     {
6010                                       if (((word >> 13) & 0x1) == 0)
6011                                         {
6012                                           if (((word >> 14) & 0x1) == 0)
6013                                             {
6014                                               if (((word >> 15) & 0x1) == 0)
6015                                                 {
6016                                                   if (((word >> 22) & 0x1) == 0)
6017                                                     {
6018                                                       if (((word >> 23) & 0x1) == 0)
6019                                                         {
6020                                                           if (((word >> 29) & 0x1) == 0)
6021                                                             {
6022                                                               /* 33222222222211111111110000000000
6023                                                                  10987654321098765432109876543210
6024                                                                  xxxxxxxxxx111000xxxxx100011100xx
6025                                                                  and.  */
6026                                                               return 251;
6027                                                             }
6028                                                           else
6029                                                             {
6030                                                               /* 33222222222211111111110000000000
6031                                                                  10987654321098765432109876543210
6032                                                                  xxxxxxxxxx111000xxxxx100011101xx
6033                                                                  eor.  */
6034                                                               return 290;
6035                                                             }
6036                                                         }
6037                                                       else
6038                                                         {
6039                                                           if (((word >> 29) & 0x1) == 0)
6040                                                             {
6041                                                               /* 33222222222211111111110000000000
6042                                                                  10987654321098765432109876543210
6043                                                                  xxxxxxxxxx111000xxxxx101011100xx
6044                                                                  orr.  */
6045                                                               return 258;
6046                                                             }
6047                                                           else
6048                                                             {
6049                                                               /* 33222222222211111111110000000000
6050                                                                  10987654321098765432109876543210
6051                                                                  xxxxxxxxxx111000xxxxx101011101xx
6052                                                                  bit.  */
6053                                                               return 297;
6054                                                             }
6055                                                         }
6056                                                     }
6057                                                   else
6058                                                     {
6059                                                       if (((word >> 23) & 0x1) == 0)
6060                                                         {
6061                                                           if (((word >> 29) & 0x1) == 0)
6062                                                             {
6063                                                               /* 33222222222211111111110000000000
6064                                                                  10987654321098765432109876543210
6065                                                                  xxxxxxxxxx111000xxxxx110011100xx
6066                                                                  bic.  */
6067                                                               return 252;
6068                                                             }
6069                                                           else
6070                                                             {
6071                                                               /* 33222222222211111111110000000000
6072                                                                  10987654321098765432109876543210
6073                                                                  xxxxxxxxxx111000xxxxx110011101xx
6074                                                                  bsl.  */
6075                                                               return 291;
6076                                                             }
6077                                                         }
6078                                                       else
6079                                                         {
6080                                                           if (((word >> 29) & 0x1) == 0)
6081                                                             {
6082                                                               /* 33222222222211111111110000000000
6083                                                                  10987654321098765432109876543210
6084                                                                  xxxxxxxxxx111000xxxxx111011100xx
6085                                                                  orn.  */
6086                                                               return 260;
6087                                                             }
6088                                                           else
6089                                                             {
6090                                                               /* 33222222222211111111110000000000
6091                                                                  10987654321098765432109876543210
6092                                                                  xxxxxxxxxx111000xxxxx111011101xx
6093                                                                  bif.  */
6094                                                               return 298;
6095                                                             }
6096                                                         }
6097                                                     }
6098                                                 }
6099                                               else
6100                                                 {
6101                                                   if (((word >> 29) & 0x1) == 0)
6102                                                     {
6103                                                       /* 33222222222211111111110000000000
6104                                                          10987654321098765432109876543210
6105                                                          xxxxxxxxxx111001xxxxx1xx011100xx
6106                                                          mul.  */
6107                                                       return 239;
6108                                                     }
6109                                                   else
6110                                                     {
6111                                                       /* 33222222222211111111110000000000
6112                                                          10987654321098765432109876543210
6113                                                          xxxxxxxxxx111001xxxxx1xx011101xx
6114                                                          pmul.  */
6115                                                       return 279;
6116                                                     }
6117                                                 }
6118                                             }
6119                                           else
6120                                             {
6121                                               if (((word >> 15) & 0x1) == 0)
6122                                                 {
6123                                                   if (((word >> 29) & 0x1) == 0)
6124                                                     {
6125                                                       /* 33222222222211111111110000000000
6126                                                          10987654321098765432109876543210
6127                                                          xxxxxxxxxx111010xxxxx1xx011100xx
6128                                                          sqrshl.  */
6129                                                       return 231;
6130                                                     }
6131                                                   else
6132                                                     {
6133                                                       /* 33222222222211111111110000000000
6134                                                          10987654321098765432109876543210
6135                                                          xxxxxxxxxx111010xxxxx1xx011101xx
6136                                                          uqrshl.  */
6137                                                       return 271;
6138                                                     }
6139                                                 }
6140                                               else
6141                                                 {
6142                                                   if (((word >> 29) & 0x1) == 0)
6143                                                     {
6144                                                       /* 33222222222211111111110000000000
6145                                                          10987654321098765432109876543210
6146                                                          xxxxxxxxxx111011xxxxx1xx011100xx
6147                                                          fmulx.  */
6148                                                       return 247;
6149                                                     }
6150                                                   else
6151                                                     {
6152                                                       /* 33222222222211111111110000000000
6153                                                          10987654321098765432109876543210
6154                                                          xxxxxxxxxx111011xxxxx1xx011101xx
6155                                                          fmul.  */
6156                                                       return 285;
6157                                                     }
6158                                                 }
6159                                             }
6160                                         }
6161                                       else
6162                                         {
6163                                           if (((word >> 14) & 0x1) == 0)
6164                                             {
6165                                               if (((word >> 15) & 0x1) == 0)
6166                                                 {
6167                                                   if (((word >> 29) & 0x1) == 0)
6168                                                     {
6169                                                       /* 33222222222211111111110000000000
6170                                                          10987654321098765432109876543210
6171                                                          xxxxxxxxxx111100xxxxx1xx011100xx
6172                                                          cmge.  */
6173                                                       return 227;
6174                                                     }
6175                                                   else
6176                                                     {
6177                                                       /* 33222222222211111111110000000000
6178                                                          10987654321098765432109876543210
6179                                                          xxxxxxxxxx111100xxxxx1xx011101xx
6180                                                          cmhs.  */
6181                                                       return 267;
6182                                                     }
6183                                                 }
6184                                               else
6185                                                 {
6186                                                   /* 33222222222211111111110000000000
6187                                                      10987654321098765432109876543210
6188                                                      xxxxxxxxxx111101xxxxx1xx01110xxx
6189                                                      addp.  */
6190                                                   return 243;
6191                                                 }
6192                                             }
6193                                           else
6194                                             {
6195                                               if (((word >> 15) & 0x1) == 0)
6196                                                 {
6197                                                   if (((word >> 29) & 0x1) == 0)
6198                                                     {
6199                                                       /* 33222222222211111111110000000000
6200                                                          10987654321098765432109876543210
6201                                                          xxxxxxxxxx111110xxxxx1xx011100xx
6202                                                          saba.  */
6203                                                       return 235;
6204                                                     }
6205                                                   else
6206                                                     {
6207                                                       /* 33222222222211111111110000000000
6208                                                          10987654321098765432109876543210
6209                                                          xxxxxxxxxx111110xxxxx1xx011101xx
6210                                                          uaba.  */
6211                                                       return 275;
6212                                                     }
6213                                                 }
6214                                               else
6215                                                 {
6216                                                   if (((word >> 23) & 0x1) == 0)
6217                                                     {
6218                                                       if (((word >> 29) & 0x1) == 0)
6219                                                         {
6220                                                           /* 33222222222211111111110000000000
6221                                                              10987654321098765432109876543210
6222                                                              xxxxxxxxxx111111xxxxx1x0011100xx
6223                                                              frecps.  */
6224                                                           return 250;
6225                                                         }
6226                                                       else
6227                                                         {
6228                                                           /* 33222222222211111111110000000000
6229                                                              10987654321098765432109876543210
6230                                                              xxxxxxxxxx111111xxxxx1x0011101xx
6231                                                              fdiv.  */
6232                                                           return 289;
6233                                                         }
6234                                                     }
6235                                                   else
6236                                                     {
6237                                                       /* 33222222222211111111110000000000
6238                                                          10987654321098765432109876543210
6239                                                          xxxxxxxxxx111111xxxxx1x101110xxx
6240                                                          frsqrts.  */
6241                                                       return 257;
6242                                                     }
6243                                                 }
6244                                             }
6245                                         }
6246                                     }
6247                                 }
6248                               else
6249                                 {
6250                                   if (((word >> 29) & 0x1) == 0)
6251                                     {
6252                                       if (((word >> 30) & 0x1) == 0)
6253                                         {
6254                                           /* 33222222222211111111110000000000
6255                                              10987654321098765432109876543210
6256                                              xxxxxxxxxx11xxxxxxxxx1xx0111100x
6257                                              fcsel.  */
6258                                           return 648;
6259                                         }
6260                                       else
6261                                         {
6262                                           if (((word >> 12) & 0x1) == 0)
6263                                             {
6264                                               if (((word >> 13) & 0x1) == 0)
6265                                                 {
6266                                                   if (((word >> 14) & 0x1) == 0)
6267                                                     {
6268                                                       if (((word >> 15) & 0x1) == 0)
6269                                                         {
6270                                                           /* 33222222222211111111110000000000
6271                                                              10987654321098765432109876543210
6272                                                              xxxxxxxxxx110000xxxxx1xx0111101x
6273                                                              sqadd.  */
6274                                                           return 438;
6275                                                         }
6276                                                       else
6277                                                         {
6278                                                           /* 33222222222211111111110000000000
6279                                                              10987654321098765432109876543210
6280                                                              xxxxxxxxxx110001xxxxx1xx0111101x
6281                                                              cmtst.  */
6282                                                           return 452;
6283                                                         }
6284                                                     }
6285                                                   else
6286                                                     {
6287                                                       /* 33222222222211111111110000000000
6288                                                          10987654321098765432109876543210
6289                                                          xxxxxxxxxx11001xxxxxx1xx0111101x
6290                                                          sqshl.  */
6291                                                       return 440;
6292                                                     }
6293                                                 }
6294                                               else
6295                                                 {
6296                                                   /* 33222222222211111111110000000000
6297                                                      10987654321098765432109876543210
6298                                                      xxxxxxxxxx1101xxxxxxx1xx0111101x
6299                                                      sqsub.  */
6300                                                   return 439;
6301                                                 }
6302                                             }
6303                                           else
6304                                             {
6305                                               if (((word >> 13) & 0x1) == 0)
6306                                                 {
6307                                                   if (((word >> 15) & 0x1) == 0)
6308                                                     {
6309                                                       /* 33222222222211111111110000000000
6310                                                          10987654321098765432109876543210
6311                                                          xxxxxxxxxx1110x0xxxxx1xx0111101x
6312                                                          sqrshl.  */
6313                                                       return 441;
6314                                                     }
6315                                                   else
6316                                                     {
6317                                                       /* 33222222222211111111110000000000
6318                                                          10987654321098765432109876543210
6319                                                          xxxxxxxxxx1110x1xxxxx1xx0111101x
6320                                                          fmulx.  */
6321                                                       return 443;
6322                                                     }
6323                                                 }
6324                                               else
6325                                                 {
6326                                                   if (((word >> 14) & 0x1) == 0)
6327                                                     {
6328                                                       /* 33222222222211111111110000000000
6329                                                          10987654321098765432109876543210
6330                                                          xxxxxxxxxx11110xxxxxx1xx0111101x
6331                                                          cmge.  */
6332                                                       return 448;
6333                                                     }
6334                                                   else
6335                                                     {
6336                                                       if (((word >> 23) & 0x1) == 0)
6337                                                         {
6338                                                           /* 33222222222211111111110000000000
6339                                                              10987654321098765432109876543210
6340                                                              xxxxxxxxxx11111xxxxxx1x00111101x
6341                                                              frecps.  */
6342                                                           return 445;
6343                                                         }
6344                                                       else
6345                                                         {
6346                                                           /* 33222222222211111111110000000000
6347                                                              10987654321098765432109876543210
6348                                                              xxxxxxxxxx11111xxxxxx1x10111101x
6349                                                              frsqrts.  */
6350                                                           return 446;
6351                                                         }
6352                                                     }
6353                                                 }
6354                                             }
6355                                         }
6356                                     }
6357                                   else
6358                                     {
6359                                       if (((word >> 12) & 0x1) == 0)
6360                                         {
6361                                           if (((word >> 13) & 0x1) == 0)
6362                                             {
6363                                               if (((word >> 14) & 0x1) == 0)
6364                                                 {
6365                                                   if (((word >> 15) & 0x1) == 0)
6366                                                     {
6367                                                       /* 33222222222211111111110000000000
6368                                                          10987654321098765432109876543210
6369                                                          xxxxxxxxxx110000xxxxx1xx011111xx
6370                                                          uqadd.  */
6371                                                       return 453;
6372                                                     }
6373                                                   else
6374                                                     {
6375                                                       /* 33222222222211111111110000000000
6376                                                          10987654321098765432109876543210
6377                                                          xxxxxxxxxx110001xxxxx1xx011111xx
6378                                                          cmeq.  */
6379                                                       return 468;
6380                                                     }
6381                                                 }
6382                                               else
6383                                                 {
6384                                                   /* 33222222222211111111110000000000
6385                                                      10987654321098765432109876543210
6386                                                      xxxxxxxxxx11001xxxxxx1xx011111xx
6387                                                      uqshl.  */
6388                                                   return 455;
6389                                                 }
6390                                             }
6391                                           else
6392                                             {
6393                                               if (((word >> 14) & 0x1) == 0)
6394                                                 {
6395                                                   /* 33222222222211111111110000000000
6396                                                      10987654321098765432109876543210
6397                                                      xxxxxxxxxx11010xxxxxx1xx011111xx
6398                                                      uqsub.  */
6399                                                   return 454;
6400                                                 }
6401                                               else
6402                                                 {
6403                                                   if (((word >> 23) & 0x1) == 0)
6404                                                     {
6405                                                       /* 33222222222211111111110000000000
6406                                                          10987654321098765432109876543210
6407                                                          xxxxxxxxxx11011xxxxxx1x0011111xx
6408                                                          facge.  */
6409                                                       return 459;
6410                                                     }
6411                                                   else
6412                                                     {
6413                                                       /* 33222222222211111111110000000000
6414                                                          10987654321098765432109876543210
6415                                                          xxxxxxxxxx11011xxxxxx1x1011111xx
6416                                                          facgt.  */
6417                                                       return 462;
6418                                                     }
6419                                                 }
6420                                             }
6421                                         }
6422                                       else
6423                                         {
6424                                           if (((word >> 13) & 0x1) == 0)
6425                                             {
6426                                               /* 33222222222211111111110000000000
6427                                                  10987654321098765432109876543210
6428                                                  xxxxxxxxxx1110xxxxxxx1xx011111xx
6429                                                  uqrshl.  */
6430                                               return 456;
6431                                             }
6432                                           else
6433                                             {
6434                                               /* 33222222222211111111110000000000
6435                                                  10987654321098765432109876543210
6436                                                  xxxxxxxxxx1111xxxxxxx1xx011111xx
6437                                                  cmhs.  */
6438                                               return 464;
6439                                             }
6440                                         }
6441                                     }
6442                                 }
6443                             }
6444                         }
6445                     }
6446                 }
6447               else
6448                 {
6449                   if (((word >> 15) & 0x1) == 0)
6450                     {
6451                       if (((word >> 28) & 0x1) == 0)
6452                         {
6453                           if (((word >> 10) & 0x1) == 0)
6454                             {
6455                               if (((word >> 12) & 0x1) == 0)
6456                                 {
6457                                   if (((word >> 13) & 0x1) == 0)
6458                                     {
6459                                       if (((word >> 14) & 0x1) == 0)
6460                                         {
6461                                           /* 33222222222211111111110000000000
6462                                              10987654321098765432109876543210
6463                                              xxxxxxxxxx0x0000xxxxxxxx11110xxx
6464                                              mla.  */
6465                                           return 110;
6466                                         }
6467                                       else
6468                                         {
6469                                           /* 33222222222211111111110000000000
6470                                              10987654321098765432109876543210
6471                                              xxxxxxxxxx0x0010xxxxxxxx11110xxx
6472                                              mls.  */
6473                                           return 113;
6474                                         }
6475                                     }
6476                                   else
6477                                     {
6478                                       if (((word >> 14) & 0x1) == 0)
6479                                         {
6480                                           if (((word >> 29) & 0x1) == 0)
6481                                             {
6482                                               if (((word >> 30) & 0x1) == 0)
6483                                                 {
6484                                                   /* 33222222222211111111110000000000
6485                                                      10987654321098765432109876543210
6486                                                      xxxxxxxxxx0x0100xxxxxxxx1111000x
6487                                                      smlal.  */
6488                                                   return 92;
6489                                                 }
6490                                               else
6491                                                 {
6492                                                   /* 33222222222211111111110000000000
6493                                                      10987654321098765432109876543210
6494                                                      xxxxxxxxxx0x0100xxxxxxxx1111001x
6495                                                      smlal2.  */
6496                                                   return 93;
6497                                                 }
6498                                             }
6499                                           else
6500                                             {
6501                                               if (((word >> 30) & 0x1) == 0)
6502                                                 {
6503                                                   /* 33222222222211111111110000000000
6504                                                      10987654321098765432109876543210
6505                                                      xxxxxxxxxx0x0100xxxxxxxx1111010x
6506                                                      umlal.  */
6507                                                   return 111;
6508                                                 }
6509                                               else
6510                                                 {
6511                                                   /* 33222222222211111111110000000000
6512                                                      10987654321098765432109876543210
6513                                                      xxxxxxxxxx0x0100xxxxxxxx1111011x
6514                                                      umlal2.  */
6515                                                   return 112;
6516                                                 }
6517                                             }
6518                                         }
6519                                       else
6520                                         {
6521                                           if (((word >> 29) & 0x1) == 0)
6522                                             {
6523                                               if (((word >> 30) & 0x1) == 0)
6524                                                 {
6525                                                   /* 33222222222211111111110000000000
6526                                                      10987654321098765432109876543210
6527                                                      xxxxxxxxxx0x0110xxxxxxxx1111000x
6528                                                      smlsl.  */
6529                                                   return 96;
6530                                                 }
6531                                               else
6532                                                 {
6533                                                   /* 33222222222211111111110000000000
6534                                                      10987654321098765432109876543210
6535                                                      xxxxxxxxxx0x0110xxxxxxxx1111001x
6536                                                      smlsl2.  */
6537                                                   return 97;
6538                                                 }
6539                                             }
6540                                           else
6541                                             {
6542                                               if (((word >> 30) & 0x1) == 0)
6543                                                 {
6544                                                   /* 33222222222211111111110000000000
6545                                                      10987654321098765432109876543210
6546                                                      xxxxxxxxxx0x0110xxxxxxxx1111010x
6547                                                      umlsl.  */
6548                                                   return 114;
6549                                                 }
6550                                               else
6551                                                 {
6552                                                   /* 33222222222211111111110000000000
6553                                                      10987654321098765432109876543210
6554                                                      xxxxxxxxxx0x0110xxxxxxxx1111011x
6555                                                      umlsl2.  */
6556                                                   return 115;
6557                                                 }
6558                                             }
6559                                         }
6560                                     }
6561                                 }
6562                               else
6563                                 {
6564                                   if (((word >> 13) & 0x1) == 0)
6565                                     {
6566                                       if (((word >> 14) & 0x1) == 0)
6567                                         {
6568                                           /* 33222222222211111111110000000000
6569                                              10987654321098765432109876543210
6570                                              xxxxxxxxxx0x1000xxxxxxxx11110xxx
6571                                              fmla.  */
6572                                           return 107;
6573                                         }
6574                                       else
6575                                         {
6576                                           /* 33222222222211111111110000000000
6577                                              10987654321098765432109876543210
6578                                              xxxxxxxxxx0x1010xxxxxxxx11110xxx
6579                                              fmls.  */
6580                                           return 108;
6581                                         }
6582                                     }
6583                                   else
6584                                     {
6585                                       if (((word >> 14) & 0x1) == 0)
6586                                         {
6587                                           if (((word >> 30) & 0x1) == 0)
6588                                             {
6589                                               /* 33222222222211111111110000000000
6590                                                  10987654321098765432109876543210
6591                                                  xxxxxxxxxx0x1100xxxxxxxx11110x0x
6592                                                  sqdmlal.  */
6593                                               return 94;
6594                                             }
6595                                           else
6596                                             {
6597                                               /* 33222222222211111111110000000000
6598                                                  10987654321098765432109876543210
6599                                                  xxxxxxxxxx0x1100xxxxxxxx11110x1x
6600                                                  sqdmlal2.  */
6601                                               return 95;
6602                                             }
6603                                         }
6604                                       else
6605                                         {
6606                                           if (((word >> 30) & 0x1) == 0)
6607                                             {
6608                                               /* 33222222222211111111110000000000
6609                                                  10987654321098765432109876543210
6610                                                  xxxxxxxxxx0x1110xxxxxxxx11110x0x
6611                                                  sqdmlsl.  */
6612                                               return 98;
6613                                             }
6614                                           else
6615                                             {
6616                                               /* 33222222222211111111110000000000
6617                                                  10987654321098765432109876543210
6618                                                  xxxxxxxxxx0x1110xxxxxxxx11110x1x
6619                                                  sqdmlsl2.  */
6620                                               return 99;
6621                                             }
6622                                         }
6623                                     }
6624                                 }
6625                             }
6626                           else
6627                             {
6628                               if (((word >> 12) & 0x1) == 0)
6629                                 {
6630                                   if (((word >> 29) & 0x1) == 0)
6631                                     {
6632                                       /* 33222222222211111111110000000000
6633                                          10987654321098765432109876543210
6634                                          xxxxxxxxxx1x0xx0xxxxxxxx111100xx
6635                                          movi.  */
6636                                       return 120;
6637                                     }
6638                                   else
6639                                     {
6640                                       /* 33222222222211111111110000000000
6641                                          10987654321098765432109876543210
6642                                          xxxxxxxxxx1x0xx0xxxxxxxx111101xx
6643                                          mvni.  */
6644                                       return 127;
6645                                     }
6646                                 }
6647                               else
6648                                 {
6649                                   if (((word >> 29) & 0x1) == 0)
6650                                     {
6651                                       /* 33222222222211111111110000000000
6652                                          10987654321098765432109876543210
6653                                          xxxxxxxxxx1x1xx0xxxxxxxx111100xx
6654                                          orr.  */
6655                                       return 121;
6656                                     }
6657                                   else
6658                                     {
6659                                       /* 33222222222211111111110000000000
6660                                          10987654321098765432109876543210
6661                                          xxxxxxxxxx1x1xx0xxxxxxxx111101xx
6662                                          bic.  */
6663                                       return 128;
6664                                     }
6665                                 }
6666                             }
6667                         }
6668                       else
6669                         {
6670                           if (((word >> 29) & 0x1) == 0)
6671                             {
6672                               if (((word >> 30) & 0x1) == 0)
6673                                 {
6674                                   if (((word >> 21) & 0x1) == 0)
6675                                     {
6676                                       /* 33222222222211111111110000000000
6677                                          10987654321098765432109876543210
6678                                          xxxxxxxxxxxxxxx0xxxxx0xx1111100x
6679                                          fmadd.  */
6680                                       return 643;
6681                                     }
6682                                   else
6683                                     {
6684                                       /* 33222222222211111111110000000000
6685                                          10987654321098765432109876543210
6686                                          xxxxxxxxxxxxxxx0xxxxx1xx1111100x
6687                                          fnmadd.  */
6688                                       return 645;
6689                                     }
6690                                 }
6691                               else
6692                                 {
6693                                   if (((word >> 10) & 0x1) == 0)
6694                                     {
6695                                       if (((word >> 13) & 0x1) == 0)
6696                                         {
6697                                           if (((word >> 14) & 0x1) == 0)
6698                                             {
6699                                               /* 33222222222211111111110000000000
6700                                                  10987654321098765432109876543210
6701                                                  xxxxxxxxxx0xx000xxxxxxxx1111101x
6702                                                  fmla.  */
6703                                               return 351;
6704                                             }
6705                                           else
6706                                             {
6707                                               /* 33222222222211111111110000000000
6708                                                  10987654321098765432109876543210
6709                                                  xxxxxxxxxx0xx010xxxxxxxx1111101x
6710                                                  fmls.  */
6711                                               return 352;
6712                                             }
6713                                         }
6714                                       else
6715                                         {
6716                                           if (((word >> 14) & 0x1) == 0)
6717                                             {
6718                                               /* 33222222222211111111110000000000
6719                                                  10987654321098765432109876543210
6720                                                  xxxxxxxxxx0xx100xxxxxxxx1111101x
6721                                                  sqdmlal.  */
6722                                               return 346;
6723                                             }
6724                                           else
6725                                             {
6726                                               /* 33222222222211111111110000000000
6727                                                  10987654321098765432109876543210
6728                                                  xxxxxxxxxx0xx110xxxxxxxx1111101x
6729                                                  sqdmlsl.  */
6730                                               return 347;
6731                                             }
6732                                         }
6733                                     }
6734                                   else
6735                                     {
6736                                       if (((word >> 12) & 0x1) == 0)
6737                                         {
6738                                           if (((word >> 13) & 0x1) == 0)
6739                                             {
6740                                               /* 33222222222211111111110000000000
6741                                                  10987654321098765432109876543210
6742                                                  xxxxxxxxxx1x00x0xxxxxxxx1111101x
6743                                                  sshr.  */
6744                                               return 469;
6745                                             }
6746                                           else
6747                                             {
6748                                               /* 33222222222211111111110000000000
6749                                                  10987654321098765432109876543210
6750                                                  xxxxxxxxxx1x01x0xxxxxxxx1111101x
6751                                                  srshr.  */
6752                                               return 471;
6753                                             }
6754                                         }
6755                                       else
6756                                         {
6757                                           if (((word >> 13) & 0x1) == 0)
6758                                             {
6759                                               if (((word >> 14) & 0x1) == 0)
6760                                                 {
6761                                                   /* 33222222222211111111110000000000
6762                                                      10987654321098765432109876543210
6763                                                      xxxxxxxxxx1x1000xxxxxxxx1111101x
6764                                                      ssra.  */
6765                                                   return 470;
6766                                                 }
6767                                               else
6768                                                 {
6769                                                   /* 33222222222211111111110000000000
6770                                                      10987654321098765432109876543210
6771                                                      xxxxxxxxxx1x1010xxxxxxxx1111101x
6772                                                      shl.  */
6773                                                   return 473;
6774                                                 }
6775                                             }
6776                                           else
6777                                             {
6778                                               if (((word >> 14) & 0x1) == 0)
6779                                                 {
6780                                                   /* 33222222222211111111110000000000
6781                                                      10987654321098765432109876543210
6782                                                      xxxxxxxxxx1x1100xxxxxxxx1111101x
6783                                                      srsra.  */
6784                                                   return 472;
6785                                                 }
6786                                               else
6787                                                 {
6788                                                   /* 33222222222211111111110000000000
6789                                                      10987654321098765432109876543210
6790                                                      xxxxxxxxxx1x1110xxxxxxxx1111101x
6791                                                      sqshl.  */
6792                                                   return 474;
6793                                                 }
6794                                             }
6795                                         }
6796                                     }
6797                                 }
6798                             }
6799                           else
6800                             {
6801                               if (((word >> 12) & 0x1) == 0)
6802                                 {
6803                                   if (((word >> 13) & 0x1) == 0)
6804                                     {
6805                                       if (((word >> 14) & 0x1) == 0)
6806                                         {
6807                                           /* 33222222222211111111110000000000
6808                                              10987654321098765432109876543210
6809                                              xxxxxxxxxxxx0000xxxxxxxx111111xx
6810                                              ushr.  */
6811                                           return 479;
6812                                         }
6813                                       else
6814                                         {
6815                                           /* 33222222222211111111110000000000
6816                                              10987654321098765432109876543210
6817                                              xxxxxxxxxxxx0010xxxxxxxx111111xx
6818                                              sri.  */
6819                                           return 483;
6820                                         }
6821                                     }
6822                                   else
6823                                     {
6824                                       if (((word >> 14) & 0x1) == 0)
6825                                         {
6826                                           /* 33222222222211111111110000000000
6827                                              10987654321098765432109876543210
6828                                              xxxxxxxxxxxx0100xxxxxxxx111111xx
6829                                              urshr.  */
6830                                           return 481;
6831                                         }
6832                                       else
6833                                         {
6834                                           /* 33222222222211111111110000000000
6835                                              10987654321098765432109876543210
6836                                              xxxxxxxxxxxx0110xxxxxxxx111111xx
6837                                              sqshlu.  */
6838                                           return 485;
6839                                         }
6840                                     }
6841                                 }
6842                               else
6843                                 {
6844                                   if (((word >> 13) & 0x1) == 0)
6845                                     {
6846                                       if (((word >> 14) & 0x1) == 0)
6847                                         {
6848                                           /* 33222222222211111111110000000000
6849                                              10987654321098765432109876543210
6850                                              xxxxxxxxxxxx1000xxxxxxxx111111xx
6851                                              usra.  */
6852                                           return 480;
6853                                         }
6854                                       else
6855                                         {
6856                                           /* 33222222222211111111110000000000
6857                                              10987654321098765432109876543210
6858                                              xxxxxxxxxxxx1010xxxxxxxx111111xx
6859                                              sli.  */
6860                                           return 484;
6861                                         }
6862                                     }
6863                                   else
6864                                     {
6865                                       if (((word >> 14) & 0x1) == 0)
6866                                         {
6867                                           /* 33222222222211111111110000000000
6868                                              10987654321098765432109876543210
6869                                              xxxxxxxxxxxx1100xxxxxxxx111111xx
6870                                              ursra.  */
6871                                           return 482;
6872                                         }
6873                                       else
6874                                         {
6875                                           /* 33222222222211111111110000000000
6876                                              10987654321098765432109876543210
6877                                              xxxxxxxxxxxx1110xxxxxxxx111111xx
6878                                              uqshl.  */
6879                                           return 486;
6880                                         }
6881                                     }
6882                                 }
6883                             }
6884                         }
6885                     }
6886                   else
6887                     {
6888                       if (((word >> 28) & 0x1) == 0)
6889                         {
6890                           if (((word >> 10) & 0x1) == 0)
6891                             {
6892                               if (((word >> 12) & 0x1) == 0)
6893                                 {
6894                                   if (((word >> 13) & 0x1) == 0)
6895                                     {
6896                                       if (((word >> 14) & 0x1) == 0)
6897                                         {
6898                                           /* 33222222222211111111110000000000
6899                                              10987654321098765432109876543210
6900                                              xxxxxxxxxx0x0001xxxxxxxx11110xxx
6901                                              mul.  */
6902                                           return 100;
6903                                         }
6904                                       else
6905                                         {
6906                                           /* 33222222222211111111110000000000
6907                                              10987654321098765432109876543210
6908                                              xxxxxxxxxx0x0011xxxxxxxx11110xxx
6909                                              sqdmulh.  */
6910                                           return 105;
6911                                         }
6912                                     }
6913                                   else
6914                                     {
6915                                       if (((word >> 29) & 0x1) == 0)
6916                                         {
6917                                           if (((word >> 30) & 0x1) == 0)
6918                                             {
6919                                               /* 33222222222211111111110000000000
6920                                                  10987654321098765432109876543210
6921                                                  xxxxxxxxxx0x01x1xxxxxxxx1111000x
6922                                                  smull.  */
6923                                               return 101;
6924                                             }
6925                                           else
6926                                             {
6927                                               /* 33222222222211111111110000000000
6928                                                  10987654321098765432109876543210
6929                                                  xxxxxxxxxx0x01x1xxxxxxxx1111001x
6930                                                  smull2.  */
6931                                               return 102;
6932                                             }
6933                                         }
6934                                       else
6935                                         {
6936                                           if (((word >> 30) & 0x1) == 0)
6937                                             {
6938                                               /* 33222222222211111111110000000000
6939                                                  10987654321098765432109876543210
6940                                                  xxxxxxxxxx0x01x1xxxxxxxx1111010x
6941                                                  umull.  */
6942                                               return 116;
6943                                             }
6944                                           else
6945                                             {
6946                                               /* 33222222222211111111110000000000
6947                                                  10987654321098765432109876543210
6948                                                  xxxxxxxxxx0x01x1xxxxxxxx1111011x
6949                                                  umull2.  */
6950                                               return 117;
6951                                             }
6952                                         }
6953                                     }
6954                                 }
6955                               else
6956                                 {
6957                                   if (((word >> 13) & 0x1) == 0)
6958                                     {
6959                                       if (((word >> 14) & 0x1) == 0)
6960                                         {
6961                                           if (((word >> 29) & 0x1) == 0)
6962                                             {
6963                                               /* 33222222222211111111110000000000
6964                                                  10987654321098765432109876543210
6965                                                  xxxxxxxxxx0x1001xxxxxxxx111100xx
6966                                                  fmul.  */
6967                                               return 109;
6968                                             }
6969                                           else
6970                                             {
6971                                               /* 33222222222211111111110000000000
6972                                                  10987654321098765432109876543210
6973                                                  xxxxxxxxxx0x1001xxxxxxxx111101xx
6974                                                  fmulx.  */
6975                                               return 118;
6976                                             }
6977                                         }
6978                                       else
6979                                         {
6980                                           /* 33222222222211111111110000000000
6981                                              10987654321098765432109876543210
6982                                              xxxxxxxxxx0x1011xxxxxxxx11110xxx
6983                                              sqrdmulh.  */
6984                                           return 106;
6985                                         }
6986                                     }
6987                                   else
6988                                     {
6989                                       if (((word >> 30) & 0x1) == 0)
6990                                         {
6991                                           /* 33222222222211111111110000000000
6992                                              10987654321098765432109876543210
6993                                              xxxxxxxxxx0x11x1xxxxxxxx11110x0x
6994                                              sqdmull.  */
6995                                           return 103;
6996                                         }
6997                                       else
6998                                         {
6999                                           /* 33222222222211111111110000000000
7000                                              10987654321098765432109876543210
7001                                              xxxxxxxxxx0x11x1xxxxxxxx11110x1x
7002                                              sqdmull2.  */
7003                                           return 104;
7004                                         }
7005                                     }
7006                                 }
7007                             }
7008                           else
7009                             {
7010                               if (((word >> 11) & 0x1) == 0)
7011                                 {
7012                                   if (((word >> 14) & 0x1) == 0)
7013                                     {
7014                                       if (((word >> 12) & 0x1) == 0)
7015                                         {
7016                                           if (((word >> 29) & 0x1) == 0)
7017                                             {
7018                                               /* 33222222222211111111110000000000
7019                                                  10987654321098765432109876543210
7020                                                  xxxxxxxxxx100x01xxxxxxxx111100xx
7021                                                  movi.  */
7022                                               return 122;
7023                                             }
7024                                           else
7025                                             {
7026                                               /* 33222222222211111111110000000000
7027                                                  10987654321098765432109876543210
7028                                                  xxxxxxxxxx100x01xxxxxxxx111101xx
7029                                                  mvni.  */
7030                                               return 129;
7031                                             }
7032                                         }
7033                                       else
7034                                         {
7035                                           if (((word >> 29) & 0x1) == 0)
7036                                             {
7037                                               /* 33222222222211111111110000000000
7038                                                  10987654321098765432109876543210
7039                                                  xxxxxxxxxx101x01xxxxxxxx111100xx
7040                                                  orr.  */
7041                                               return 123;
7042                                             }
7043                                           else
7044                                             {
7045                                               /* 33222222222211111111110000000000
7046                                                  10987654321098765432109876543210
7047                                                  xxxxxxxxxx101x01xxxxxxxx111101xx
7048                                                  bic.  */
7049                                               return 130;
7050                                             }
7051                                         }
7052                                     }
7053                                   else
7054                                     {
7055                                       if (((word >> 13) & 0x1) == 0)
7056                                         {
7057                                           if (((word >> 29) & 0x1) == 0)
7058                                             {
7059                                               /* 33222222222211111111110000000000
7060                                                  10987654321098765432109876543210
7061                                                  xxxxxxxxxx10x011xxxxxxxx111100xx
7062                                                  movi.  */
7063                                               return 124;
7064                                             }
7065                                           else
7066                                             {
7067                                               /* 33222222222211111111110000000000
7068                                                  10987654321098765432109876543210
7069                                                  xxxxxxxxxx10x011xxxxxxxx111101xx
7070                                                  mvni.  */
7071                                               return 131;
7072                                             }
7073                                         }
7074                                       else
7075                                         {
7076                                           if (((word >> 12) & 0x1) == 0)
7077                                             {
7078                                               if (((word >> 29) & 0x1) == 0)
7079                                                 {
7080                                                   /* 33222222222211111111110000000000
7081                                                      10987654321098765432109876543210
7082                                                      xxxxxxxxxx100111xxxxxxxx111100xx
7083                                                      movi.  */
7084                                                   return 125;
7085                                                 }
7086                                               else
7087                                                 {
7088                                                   /* 33222222222211111111110000000000
7089                                                      10987654321098765432109876543210
7090                                                      xxxxxxxxxx100111xxxxxxxx111101xx
7091                                                      movi.  */
7092                                                   return 132;
7093                                                 }
7094                                             }
7095                                           else
7096                                             {
7097                                               if (((word >> 29) & 0x1) == 0)
7098                                                 {
7099                                                   /* 33222222222211111111110000000000
7100                                                      10987654321098765432109876543210
7101                                                      xxxxxxxxxx101111xxxxxxxx111100xx
7102                                                      fmov.  */
7103                                                   return 126;
7104                                                 }
7105                                               else
7106                                                 {
7107                                                   /* 33222222222211111111110000000000
7108                                                      10987654321098765432109876543210
7109                                                      xxxxxxxxxx101111xxxxxxxx111101xx
7110                                                      fmov.  */
7111                                                   return 134;
7112                                                 }
7113                                             }
7114                                         }
7115                                     }
7116                                 }
7117                               else
7118                                 {
7119                                   if (((word >> 12) & 0x1) == 0)
7120                                     {
7121                                       if (((word >> 29) & 0x1) == 0)
7122                                         {
7123                                           if (((word >> 30) & 0x1) == 0)
7124                                             {
7125                                               /* 33222222222211111111110000000000
7126                                                  10987654321098765432109876543210
7127                                                  xxxxxxxxxx110xx1xxxxxxxx1111000x
7128                                                  rshrn.  */
7129                                               return 307;
7130                                             }
7131                                           else
7132                                             {
7133                                               /* 33222222222211111111110000000000
7134                                                  10987654321098765432109876543210
7135                                                  xxxxxxxxxx110xx1xxxxxxxx1111001x
7136                                                  rshrn2.  */
7137                                               return 308;
7138                                             }
7139                                         }
7140                                       else
7141                                         {
7142                                           if (((word >> 30) & 0x1) == 0)
7143                                             {
7144                                               /* 33222222222211111111110000000000
7145                                                  10987654321098765432109876543210
7146                                                  xxxxxxxxxx110xx1xxxxxxxx1111010x
7147                                                  sqrshrun.  */
7148                                               return 329;
7149                                             }
7150                                           else
7151                                             {
7152                                               /* 33222222222211111111110000000000
7153                                                  10987654321098765432109876543210
7154                                                  xxxxxxxxxx110xx1xxxxxxxx1111011x
7155                                                  sqrshrun2.  */
7156                                               return 330;
7157                                             }
7158                                         }
7159                                     }
7160                                   else
7161                                     {
7162                                       if (((word >> 13) & 0x1) == 0)
7163                                         {
7164                                           if (((word >> 29) & 0x1) == 0)
7165                                             {
7166                                               if (((word >> 30) & 0x1) == 0)
7167                                                 {
7168                                                   /* 33222222222211111111110000000000
7169                                                      10987654321098765432109876543210
7170                                                      xxxxxxxxxx1110x1xxxxxxxx1111000x
7171                                                      sqrshrn.  */
7172                                                   return 311;
7173                                                 }
7174                                               else
7175                                                 {
7176                                                   /* 33222222222211111111110000000000
7177                                                      10987654321098765432109876543210
7178                                                      xxxxxxxxxx1110x1xxxxxxxx1111001x
7179                                                      sqrshrn2.  */
7180                                                   return 312;
7181                                                 }
7182                                             }
7183                                           else
7184                                             {
7185                                               if (((word >> 30) & 0x1) == 0)
7186                                                 {
7187                                                   /* 33222222222211111111110000000000
7188                                                      10987654321098765432109876543210
7189                                                      xxxxxxxxxx1110x1xxxxxxxx1111010x
7190                                                      uqrshrn.  */
7191                                                   return 333;
7192                                                 }
7193                                               else
7194                                                 {
7195                                                   /* 33222222222211111111110000000000
7196                                                      10987654321098765432109876543210
7197                                                      xxxxxxxxxx1110x1xxxxxxxx1111011x
7198                                                      uqrshrn2.  */
7199                                                   return 334;
7200                                                 }
7201                                             }
7202                                         }
7203                                       else
7204                                         {
7205                                           if (((word >> 29) & 0x1) == 0)
7206                                             {
7207                                               /* 33222222222211111111110000000000
7208                                                  10987654321098765432109876543210
7209                                                  xxxxxxxxxx1111x1xxxxxxxx111100xx
7210                                                  fcvtzs.  */
7211                                               return 318;
7212                                             }
7213                                           else
7214                                             {
7215                                               /* 33222222222211111111110000000000
7216                                                  10987654321098765432109876543210
7217                                                  xxxxxxxxxx1111x1xxxxxxxx111101xx
7218                                                  fcvtzu.  */
7219                                               return 340;
7220                                             }
7221                                         }
7222                                     }
7223                                 }
7224                             }
7225                         }
7226                       else
7227                         {
7228                           if (((word >> 29) & 0x1) == 0)
7229                             {
7230                               if (((word >> 30) & 0x1) == 0)
7231                                 {
7232                                   if (((word >> 21) & 0x1) == 0)
7233                                     {
7234                                       /* 33222222222211111111110000000000
7235                                          10987654321098765432109876543210
7236                                          xxxxxxxxxxxxxxx1xxxxx0xx1111100x
7237                                          fmsub.  */
7238                                       return 644;
7239                                     }
7240                                   else
7241                                     {
7242                                       /* 33222222222211111111110000000000
7243                                          10987654321098765432109876543210
7244                                          xxxxxxxxxxxxxxx1xxxxx1xx1111100x
7245                                          fnmsub.  */
7246                                       return 646;
7247                                     }
7248                                 }
7249                               else
7250                                 {
7251                                   if (((word >> 10) & 0x1) == 0)
7252                                     {
7253                                       if (((word >> 12) & 0x1) == 0)
7254                                         {
7255                                           /* 33222222222211111111110000000000
7256                                              10987654321098765432109876543210
7257                                              xxxxxxxxxx0x0xx1xxxxxxxx1111101x
7258                                              sqdmulh.  */
7259                                           return 349;
7260                                         }
7261                                       else
7262                                         {
7263                                           if (((word >> 13) & 0x1) == 0)
7264                                             {
7265                                               if (((word >> 14) & 0x1) == 0)
7266                                                 {
7267                                                   /* 33222222222211111111110000000000
7268                                                      10987654321098765432109876543210
7269                                                      xxxxxxxxxx0x1001xxxxxxxx1111101x
7270                                                      fmul.  */
7271                                                   return 353;
7272                                                 }
7273                                               else
7274                                                 {
7275                                                   /* 33222222222211111111110000000000
7276                                                      10987654321098765432109876543210
7277                                                      xxxxxxxxxx0x1011xxxxxxxx1111101x
7278                                                      sqrdmulh.  */
7279                                                   return 350;
7280                                                 }
7281                                             }
7282                                           else
7283                                             {
7284                                               /* 33222222222211111111110000000000
7285                                                  10987654321098765432109876543210
7286                                                  xxxxxxxxxx0x11x1xxxxxxxx1111101x
7287                                                  sqdmull.  */
7288                                               return 348;
7289                                             }
7290                                         }
7291                                     }
7292                                   else
7293                                     {
7294                                       if (((word >> 11) & 0x1) == 0)
7295                                         {
7296                                           if (((word >> 12) & 0x1) == 0)
7297                                             {
7298                                               /* 33222222222211111111110000000000
7299                                                  10987654321098765432109876543210
7300                                                  xxxxxxxxxx100xx1xxxxxxxx1111101x
7301                                                  scvtf.  */
7302                                               return 477;
7303                                             }
7304                                           else
7305                                             {
7306                                               /* 33222222222211111111110000000000
7307                                                  10987654321098765432109876543210
7308                                                  xxxxxxxxxx101xx1xxxxxxxx1111101x
7309                                                  sqshrn.  */
7310                                               return 475;
7311                                             }
7312                                         }
7313                                       else
7314                                         {
7315                                           if (((word >> 13) & 0x1) == 0)
7316                                             {
7317                                               /* 33222222222211111111110000000000
7318                                                  10987654321098765432109876543210
7319                                                  xxxxxxxxxx11x0x1xxxxxxxx1111101x
7320                                                  sqrshrn.  */
7321                                               return 476;
7322                                             }
7323                                           else
7324                                             {
7325                                               /* 33222222222211111111110000000000
7326                                                  10987654321098765432109876543210
7327                                                  xxxxxxxxxx11x1x1xxxxxxxx1111101x
7328                                                  fcvtzs.  */
7329                                               return 478;
7330                                             }
7331                                         }
7332                                     }
7333                                 }
7334                             }
7335                           else
7336                             {
7337                               if (((word >> 10) & 0x1) == 0)
7338                                 {
7339                                   /* 33222222222211111111110000000000
7340                                      10987654321098765432109876543210
7341                                      xxxxxxxxxx0xxxx1xxxxxxxx111111xx
7342                                      fmulx.  */
7343                                   return 354;
7344                                 }
7345                               else
7346                                 {
7347                                   if (((word >> 11) & 0x1) == 0)
7348                                     {
7349                                       if (((word >> 12) & 0x1) == 0)
7350                                         {
7351                                           if (((word >> 13) & 0x1) == 0)
7352                                             {
7353                                               /* 33222222222211111111110000000000
7354                                                  10987654321098765432109876543210
7355                                                  xxxxxxxxxx1000x1xxxxxxxx111111xx
7356                                                  sqshrun.  */
7357                                               return 487;
7358                                             }
7359                                           else
7360                                             {
7361                                               /* 33222222222211111111110000000000
7362                                                  10987654321098765432109876543210
7363                                                  xxxxxxxxxx1001x1xxxxxxxx111111xx
7364                                                  ucvtf.  */
7365                                               return 491;
7366                                             }
7367                                         }
7368                                       else
7369                                         {
7370                                           /* 33222222222211111111110000000000
7371                                              10987654321098765432109876543210
7372                                              xxxxxxxxxx101xx1xxxxxxxx111111xx
7373                                              uqshrn.  */
7374                                           return 489;
7375                                         }
7376                                     }
7377                                   else
7378                                     {
7379                                       if (((word >> 12) & 0x1) == 0)
7380                                         {
7381                                           /* 33222222222211111111110000000000
7382                                              10987654321098765432109876543210
7383                                              xxxxxxxxxx110xx1xxxxxxxx111111xx
7384                                              sqrshrun.  */
7385                                           return 488;
7386                                         }
7387                                       else
7388                                         {
7389                                           if (((word >> 13) & 0x1) == 0)
7390                                             {
7391                                               /* 33222222222211111111110000000000
7392                                                  10987654321098765432109876543210
7393                                                  xxxxxxxxxx1110x1xxxxxxxx111111xx
7394                                                  uqrshrn.  */
7395                                               return 490;
7396                                             }
7397                                           else
7398                                             {
7399                                               /* 33222222222211111111110000000000
7400                                                  10987654321098765432109876543210
7401                                                  xxxxxxxxxx1111x1xxxxxxxx111111xx
7402                                                  fcvtzu.  */
7403                                               return 492;
7404                                             }
7405                                         }
7406                                     }
7407                                 }
7408                             }
7409                         }
7410                     }
7411                 }
7412             }
7413         }
7414     }
7415 }
7416
7417 /* Lookup opcode WORD in the opcode table.  N.B. all alias
7418    opcodes are ignored here.  */
7419
7420 const aarch64_opcode *
7421 aarch64_opcode_lookup (uint32_t word)
7422 {
7423   return aarch64_opcode_table + aarch64_opcode_lookup_1 (word);
7424 }
7425
7426 const aarch64_opcode *
7427 aarch64_find_next_opcode (const aarch64_opcode *opcode)
7428 {
7429   /* Use the index as the key to locate the next opcode.  */
7430   int key = opcode - aarch64_opcode_table;
7431   int value;
7432   switch (key)
7433     {
7434     case 739: value = 743; break;       /* stnp --> stp.  */
7435     case 743: return NULL;              /* stp --> NULL.  */
7436     case 740: value = 744; break;       /* ldnp --> ldp.  */
7437     case 744: return NULL;              /* ldp --> NULL.  */
7438     case 355: value = 356; break;       /* st4 --> st1.  */
7439     case 356: value = 357; break;       /* st1 --> st2.  */
7440     case 357: value = 358; break;       /* st2 --> st3.  */
7441     case 358: return NULL;              /* st3 --> NULL.  */
7442     case 363: value = 364; break;       /* st4 --> st1.  */
7443     case 364: value = 365; break;       /* st1 --> st2.  */
7444     case 365: value = 366; break;       /* st2 --> st3.  */
7445     case 366: return NULL;              /* st3 --> NULL.  */
7446     case 359: value = 360; break;       /* ld4 --> ld1.  */
7447     case 360: value = 361; break;       /* ld1 --> ld2.  */
7448     case 361: value = 362; break;       /* ld2 --> ld3.  */
7449     case 362: return NULL;              /* ld3 --> NULL.  */
7450     case 375: value = 377; break;       /* ld1 --> ld1r.  */
7451     case 377: return NULL;              /* ld1r --> NULL.  */
7452     case 379: value = 381; break;       /* ld2 --> ld2r.  */
7453     case 381: return NULL;              /* ld2r --> NULL.  */
7454     case 376: value = 378; break;       /* ld3 --> ld3r.  */
7455     case 378: return NULL;              /* ld3r --> NULL.  */
7456     case 380: value = 382; break;       /* ld4 --> ld4r.  */
7457     case 382: return NULL;              /* ld4r --> NULL.  */
7458     case 367: value = 368; break;       /* ld4 --> ld1.  */
7459     case 368: value = 369; break;       /* ld1 --> ld2.  */
7460     case 369: value = 370; break;       /* ld2 --> ld3.  */
7461     case 370: return NULL;              /* ld3 --> NULL.  */
7462     case 387: value = 389; break;       /* ld1 --> ld1r.  */
7463     case 389: return NULL;              /* ld1r --> NULL.  */
7464     case 388: value = 390; break;       /* ld3 --> ld3r.  */
7465     case 390: return NULL;              /* ld3r --> NULL.  */
7466     case 391: value = 393; break;       /* ld2 --> ld2r.  */
7467     case 393: return NULL;              /* ld2r --> NULL.  */
7468     case 392: value = 394; break;       /* ld4 --> ld4r.  */
7469     case 394: return NULL;              /* ld4r --> NULL.  */
7470     case 120: value = 299; break;       /* movi --> sshr.  */
7471     case 299: value = 301; break;       /* sshr --> srshr.  */
7472     case 301: return NULL;              /* srshr --> NULL.  */
7473     case 127: value = 319; break;       /* mvni --> ushr.  */
7474     case 319: value = 321; break;       /* ushr --> urshr.  */
7475     case 321: value = 323; break;       /* urshr --> sri.  */
7476     case 323: value = 325; break;       /* sri --> sqshlu.  */
7477     case 325: return NULL;              /* sqshlu --> NULL.  */
7478     case 121: value = 300; break;       /* orr --> ssra.  */
7479     case 300: value = 302; break;       /* ssra --> srsra.  */
7480     case 302: value = 303; break;       /* srsra --> shl.  */
7481     case 303: value = 304; break;       /* shl --> sqshl.  */
7482     case 304: return NULL;              /* sqshl --> NULL.  */
7483     case 128: value = 320; break;       /* bic --> usra.  */
7484     case 320: value = 322; break;       /* usra --> ursra.  */
7485     case 322: value = 324; break;       /* ursra --> sli.  */
7486     case 324: value = 326; break;       /* sli --> uqshl.  */
7487     case 326: return NULL;              /* uqshl --> NULL.  */
7488     case 122: value = 305; break;       /* movi --> shrn.  */
7489     case 305: value = 306; break;       /* shrn --> shrn2.  */
7490     case 306: value = 313; break;       /* shrn2 --> sshll.  */
7491     case 313: value = 315; break;       /* sshll --> sshll2.  */
7492     case 315: return NULL;              /* sshll2 --> NULL.  */
7493     case 129: value = 327; break;       /* mvni --> sqshrun.  */
7494     case 327: value = 328; break;       /* sqshrun --> sqshrun2.  */
7495     case 328: value = 335; break;       /* sqshrun2 --> ushll.  */
7496     case 335: value = 337; break;       /* ushll --> ushll2.  */
7497     case 337: return NULL;              /* ushll2 --> NULL.  */
7498     case 123: value = 309; break;       /* orr --> sqshrn.  */
7499     case 309: value = 310; break;       /* sqshrn --> sqshrn2.  */
7500     case 310: return NULL;              /* sqshrn2 --> NULL.  */
7501     case 130: value = 331; break;       /* bic --> uqshrn.  */
7502     case 331: value = 332; break;       /* uqshrn --> uqshrn2.  */
7503     case 332: return NULL;              /* uqshrn2 --> NULL.  */
7504     case 125: value = 317; break;       /* movi --> scvtf.  */
7505     case 317: return NULL;              /* scvtf --> NULL.  */
7506     case 132: value = 133; break;       /* movi --> movi.  */
7507     case 133: value = 339; break;       /* movi --> ucvtf.  */
7508     case 339: return NULL;              /* ucvtf --> NULL.  */
7509     default: return NULL;
7510     }
7511
7512   return aarch64_opcode_table + value;
7513 }
7514
7515 const aarch64_opcode *
7516 aarch64_find_alias_opcode (const aarch64_opcode *opcode)
7517 {
7518   /* Use the index as the key to locate the alias opcode.  */
7519   int key = opcode - aarch64_opcode_table;
7520   int value;
7521   switch (key)
7522     {
7523     case 2: value = 3; break;   /* sbc --> ngc.  */
7524     case 4: value = 5; break;   /* sbcs --> ngcs.  */
7525     case 7: value = 8; break;   /* adds --> cmn.  */
7526     case 10: value = 11; break; /* subs --> cmp.  */
7527     case 12: value = 13; break; /* add --> mov.  */
7528     case 14: value = 15; break; /* adds --> cmn.  */
7529     case 17: value = 18; break; /* subs --> cmp.  */
7530     case 20: value = 21; break; /* adds --> cmn.  */
7531     case 22: value = 23; break; /* sub --> neg.  */
7532     case 24: value = 26; break; /* subs --> negs.  */
7533     case 138: value = 139; break;       /* umov --> mov.  */
7534     case 140: value = 141; break;       /* ins --> mov.  */
7535     case 142: value = 143; break;       /* ins --> mov.  */
7536     case 203: value = 204; break;       /* not --> mvn.  */
7537     case 258: value = 259; break;       /* orr --> mov.  */
7538     case 313: value = 314; break;       /* sshll --> sxtl.  */
7539     case 315: value = 316; break;       /* sshll2 --> sxtl2.  */
7540     case 335: value = 336; break;       /* ushll --> uxtl.  */
7541     case 337: value = 338; break;       /* ushll2 --> uxtl2.  */
7542     case 430: value = 431; break;       /* dup --> mov.  */
7543     case 493: value = 498; break;       /* sbfm --> sxtw.  */
7544     case 500: value = 502; break;       /* bfm --> bfxil.  */
7545     case 503: value = 507; break;       /* ubfm --> uxth.  */
7546     case 525: value = 527; break;       /* csinc --> cset.  */
7547     case 528: value = 530; break;       /* csinv --> csetm.  */
7548     case 531: value = 532; break;       /* csneg --> cneg.  */
7549     case 556: value = 557; break;       /* lslv --> lsl.  */
7550     case 558: value = 559; break;       /* lsrv --> lsr.  */
7551     case 560: value = 561; break;       /* asrv --> asr.  */
7552     case 562: value = 563; break;       /* rorv --> ror.  */
7553     case 572: value = 573; break;       /* madd --> mul.  */
7554     case 574: value = 575; break;       /* msub --> mneg.  */
7555     case 576: value = 577; break;       /* smaddl --> smull.  */
7556     case 578: value = 579; break;       /* smsubl --> smnegl.  */
7557     case 581: value = 582; break;       /* umaddl --> umull.  */
7558     case 583: value = 584; break;       /* umsubl --> umnegl.  */
7559     case 594: value = 595; break;       /* extr --> ror.  */
7560     case 693: value = 695; break;       /* sturb --> strb.  */
7561     case 694: value = 696; break;       /* ldurb --> ldrb.  */
7562     case 697: value = 698; break;       /* ldursb --> ldrsb.  */
7563     case 699: value = 701; break;       /* stur --> str.  */
7564     case 700: value = 702; break;       /* ldur --> ldr.  */
7565     case 703: value = 705; break;       /* sturh --> strh.  */
7566     case 704: value = 706; break;       /* ldurh --> ldrh.  */
7567     case 707: value = 708; break;       /* ldursh --> ldrsh.  */
7568     case 709: value = 711; break;       /* stur --> str.  */
7569     case 710: value = 712; break;       /* ldur --> ldr.  */
7570     case 713: value = 714; break;       /* ldursw --> ldrsw.  */
7571     case 715: value = 716; break;       /* prfum --> prfm.  */
7572     case 757: value = 758; break;       /* and --> bic.  */
7573     case 759: value = 760; break;       /* orr --> mov.  */
7574     case 762: value = 763; break;       /* ands --> tst.  */
7575     case 766: value = 768; break;       /* orr --> uxtw.  */
7576     case 769: value = 770; break;       /* orn --> mvn.  */
7577     case 773: value = 774; break;       /* ands --> tst.  */
7578     case 776: value = 777; break;       /* movn --> mov.  */
7579     case 778: value = 779; break;       /* movz --> mov.  */
7580     case 784: value = 790; break;       /* hint --> sevl.  */
7581     case 795: value = 799; break;       /* sys --> tlbi.  */
7582     default: return NULL;
7583     }
7584
7585   return aarch64_opcode_table + value;
7586 }
7587
7588 const aarch64_opcode *
7589 aarch64_find_next_alias_opcode (const aarch64_opcode *opcode)
7590 {
7591   /* Use the index as the key to locate the next opcode.  */
7592   int key = opcode - aarch64_opcode_table;
7593   int value;
7594   switch (key)
7595     {
7596     case 26: value = 25; break; /* negs --> cmp.  */
7597     case 498: value = 497; break;       /* sxtw --> sxth.  */
7598     case 497: value = 496; break;       /* sxth --> sxtb.  */
7599     case 496: value = 499; break;       /* sxtb --> asr.  */
7600     case 499: value = 495; break;       /* asr --> sbfx.  */
7601     case 495: value = 494; break;       /* sbfx --> sbfiz.  */
7602     case 502: value = 501; break;       /* bfxil --> bfi.  */
7603     case 507: value = 506; break;       /* uxth --> uxtb.  */
7604     case 506: value = 509; break;       /* uxtb --> lsr.  */
7605     case 509: value = 508; break;       /* lsr --> lsl.  */
7606     case 508: value = 505; break;       /* lsl --> ubfx.  */
7607     case 505: value = 504; break;       /* ubfx --> ubfiz.  */
7608     case 527: value = 526; break;       /* cset --> cinc.  */
7609     case 530: value = 529; break;       /* csetm --> cinv.  */
7610     case 768: value = 767; break;       /* uxtw --> mov.  */
7611     case 790: value = 789; break;       /* sevl --> sev.  */
7612     case 789: value = 788; break;       /* sev --> wfi.  */
7613     case 788: value = 787; break;       /* wfi --> wfe.  */
7614     case 787: value = 786; break;       /* wfe --> yield.  */
7615     case 786: value = 785; break;       /* yield --> nop.  */
7616     case 799: value = 798; break;       /* tlbi --> ic.  */
7617     case 798: value = 797; break;       /* ic --> dc.  */
7618     case 797: value = 796; break;       /* dc --> at.  */
7619     default: return NULL;
7620     }
7621
7622   return aarch64_opcode_table + value;
7623 }
7624
7625 int
7626 aarch64_extract_operand (const aarch64_operand *self,
7627                            aarch64_opnd_info *info,
7628                            aarch64_insn code, const aarch64_inst *inst)
7629 {
7630   /* Use the index as the key.  */
7631   int key = self - aarch64_operands;
7632   switch (key)
7633     {
7634     case 1:
7635     case 2:
7636     case 3:
7637     case 4:
7638     case 5:
7639     case 6:
7640     case 7:
7641     case 9:
7642     case 10:
7643     case 13:
7644     case 14:
7645     case 15:
7646     case 16:
7647     case 18:
7648     case 19:
7649     case 20:
7650     case 21:
7651     case 22:
7652     case 23:
7653     case 24:
7654     case 25:
7655     case 26:
7656     case 34:
7657     case 35:
7658       return aarch64_ext_regno (self, info, code, inst);
7659     case 8:
7660       return aarch64_ext_regrt_sysins (self, info, code, inst);
7661     case 11:
7662       return aarch64_ext_reg_extended (self, info, code, inst);
7663     case 12:
7664       return aarch64_ext_reg_shifted (self, info, code, inst);
7665     case 17:
7666       return aarch64_ext_ft (self, info, code, inst);
7667     case 27:
7668     case 28:
7669     case 29:
7670       return aarch64_ext_reglane (self, info, code, inst);
7671     case 30:
7672       return aarch64_ext_reglist (self, info, code, inst);
7673     case 31:
7674       return aarch64_ext_ldst_reglist (self, info, code, inst);
7675     case 32:
7676       return aarch64_ext_ldst_reglist_r (self, info, code, inst);
7677     case 33:
7678       return aarch64_ext_ldst_elemlist (self, info, code, inst);
7679     case 36:
7680     case 45:
7681     case 46:
7682     case 47:
7683     case 48:
7684     case 49:
7685     case 50:
7686     case 51:
7687     case 52:
7688     case 53:
7689     case 54:
7690     case 55:
7691     case 56:
7692     case 57:
7693     case 64:
7694     case 65:
7695     case 66:
7696     case 67:
7697     case 68:
7698       return aarch64_ext_imm (self, info, code, inst);
7699     case 37:
7700     case 38:
7701       return aarch64_ext_advsimd_imm_shift (self, info, code, inst);
7702     case 39:
7703     case 40:
7704     case 41:
7705       return aarch64_ext_advsimd_imm_modified (self, info, code, inst);
7706     case 42:
7707       return aarch64_ext_shll_imm (self, info, code, inst);
7708     case 58:
7709       return aarch64_ext_limm (self, info, code, inst);
7710     case 59:
7711       return aarch64_ext_aimm (self, info, code, inst);
7712     case 60:
7713       return aarch64_ext_imm_half (self, info, code, inst);
7714     case 61:
7715       return aarch64_ext_fbits (self, info, code, inst);
7716     case 63:
7717       return aarch64_ext_cond (self, info, code, inst);
7718     case 69:
7719     case 75:
7720       return aarch64_ext_addr_simple (self, info, code, inst);
7721     case 70:
7722       return aarch64_ext_addr_regoff (self, info, code, inst);
7723     case 71:
7724     case 72:
7725     case 73:
7726       return aarch64_ext_addr_simm (self, info, code, inst);
7727     case 74:
7728       return aarch64_ext_addr_uimm12 (self, info, code, inst);
7729     case 76:
7730       return aarch64_ext_simd_addr_post (self, info, code, inst);
7731     case 77:
7732       return aarch64_ext_sysreg (self, info, code, inst);
7733     case 78:
7734       return aarch64_ext_pstatefield (self, info, code, inst);
7735     case 79:
7736     case 80:
7737     case 81:
7738     case 82:
7739       return aarch64_ext_sysins_op (self, info, code, inst);
7740     case 83:
7741     case 84:
7742       return aarch64_ext_barrier (self, info, code, inst);
7743     case 85:
7744       return aarch64_ext_prfop (self, info, code, inst);
7745     default: assert (0); abort ();
7746     }
7747 }