opcodes/aarch64-dis-2.c

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