opcodes/aarch64-dis-2.c

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